Emergency Bypass
@@ -74,7 +73,7 @@ jobs:
- name: install parity-publish
# Set the target dir to cache the build.
- run: CARGO_TARGET_DIR=./target/ cargo install parity-publish@0.8.0 -q
+ run: CARGO_TARGET_DIR=./target/ cargo install parity-publish@0.8.0 --locked -q
- name: check semver
run: |
diff --git a/.github/workflows/checks-quick.yml b/.github/workflows/checks-quick.yml
index ee4bd62a558d48b4d57be9a9208b2e4109f7a6ff..9e36d2bcb2e9eed6266bfe4a940a43ace7216518 100644
--- a/.github/workflows/checks-quick.yml
+++ b/.github/workflows/checks-quick.yml
@@ -15,34 +15,25 @@ concurrency:
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
+
+ preflight:
+ uses: ./.github/workflows/reusable-preflight.yml
+
fmt:
runs-on: ubuntu-latest
timeout-minutes: 20
- needs: [set-image]
+ needs: [preflight]
container:
- image: ${{ needs.set-image.outputs.IMAGE }}
+ image: ${{ needs.preflight.outputs.IMAGE }}
steps:
- - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: Cargo fmt
run: cargo +nightly fmt --all -- --check
check-dependency-rules:
runs-on: ubuntu-latest
timeout-minutes: 20
steps:
- - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: check dependency rules
run: |
cd substrate/
@@ -50,11 +41,11 @@ jobs:
check-rust-feature-propagation:
runs-on: ubuntu-latest
timeout-minutes: 20
- needs: [set-image]
+ needs: [preflight]
container:
- image: ${{ needs.set-image.outputs.IMAGE }}
+ image: ${{ needs.preflight.outputs.IMAGE }}
steps:
- - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: fetch deps
run: |
# Pull all dependencies eagerly:
@@ -66,21 +57,21 @@ jobs:
test-rust-features:
runs-on: ubuntu-latest
timeout-minutes: 20
- needs: [set-image]
+ needs: [preflight]
container:
- image: ${{ needs.set-image.outputs.IMAGE }}
+ image: ${{ needs.preflight.outputs.IMAGE }}
steps:
- - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: run rust features
run: bash .gitlab/rust-features.sh .
check-toml-format:
runs-on: ubuntu-latest
timeout-minutes: 20
- needs: [set-image]
+ needs: [preflight]
container:
- image: ${{ needs.set-image.outputs.IMAGE }}
+ image: ${{ needs.preflight.outputs.IMAGE }}
steps:
- - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: check toml format
run: |
taplo format --check --config .config/taplo.toml
@@ -89,7 +80,7 @@ jobs:
runs-on: ubuntu-latest
timeout-minutes: 20
steps:
- - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.0 (22. Sep 2023)
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.0 (22. Sep 2023)
- name: install python deps
run: |
sudo apt-get update && sudo apt-get install -y python3-pip python3
@@ -100,6 +91,8 @@ jobs:
--exclude
"substrate/frame/contracts/fixtures/build"
"substrate/frame/contracts/fixtures/contracts/common"
+ "substrate/frame/revive/fixtures/build"
+ "substrate/frame/revive/fixtures/contracts/common"
- name: deny git deps
run: python3 .github/scripts/deny-git-deps.py .
check-markdown:
@@ -107,7 +100,7 @@ jobs:
timeout-minutes: 20
steps:
- name: Checkout sources
- uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+ uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: Setup Node.js
uses: actions/setup-node@v4.0.3
with:
@@ -128,11 +121,11 @@ jobs:
check-umbrella:
runs-on: ubuntu-latest
timeout-minutes: 20
- needs: [set-image]
+ needs: [preflight]
container:
- image: ${{ needs.set-image.outputs.IMAGE }}
+ image: ${{ needs.preflight.outputs.IMAGE }}
steps:
- - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.0 (22. Sep 2023)
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.0 (22. Sep 2023)
- name: install python deps
run: pip3 install "cargo-workspace>=1.2.4" toml
- name: check umbrella correctness
@@ -154,3 +147,54 @@ jobs:
git diff
exit 1
fi
+ check-fail-ci:
+ runs-on: ubuntu-latest
+ container:
+ # there's no "rg" in ci-unified, and tools is a smaller image anyway
+ image: "paritytech/tools:latest"
+ # paritytech/tools uses "nonroot" user by default, which doesn't have enough
+ # permissions to create GHA context
+ options: --user root
+ steps:
+ - name: Fetch latest code
+ uses: actions/checkout@v4
+ - name: Check
+ run: |
+ set +e
+ rg --line-number --hidden --type rust --glob '!{.git,target}' "$ASSERT_REGEX" .; exit_status=$?
+ if [ $exit_status -eq 0 ]; then
+ echo "$ASSERT_REGEX was found, exiting with 1";
+ exit 1;
+ else
+ echo "No $ASSERT_REGEX was found, exiting with 0";
+ exit 0;
+ fi
+ env:
+ ASSERT_REGEX: "FAIL-CI"
+ GIT_DEPTH: 1
+
+ confirm-required-checks-quick-jobs-passed:
+ runs-on: ubuntu-latest
+ name: All quick checks passed
+ # If any new job gets added, be sure to add it to this array
+ needs:
+ - fmt
+ - check-dependency-rules
+ - check-rust-feature-propagation
+ - test-rust-features
+ - check-toml-format
+ - check-workspace
+ - check-markdown
+ - check-umbrella
+ - check-fail-ci
+ if: always() && !cancelled()
+ steps:
+ - run: |
+ tee resultfile <<< '${{ toJSON(needs) }}'
+ FAILURES=$(cat resultfile | grep '"result": "failure"' | wc -l)
+ if [ $FAILURES -gt 0 ]; then
+ echo "### At least one required job failed ❌" >> $GITHUB_STEP_SUMMARY
+ exit 1
+ else
+ echo '### Good job! All the required jobs passed 🚀' >> $GITHUB_STEP_SUMMARY
+ fi
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
new file mode 100644
index 0000000000000000000000000000000000000000..f765d79254c856195271978942ea2eb550f3e7f6
--- /dev/null
+++ b/.github/workflows/checks.yml
@@ -0,0 +1,94 @@
+name: Checks
+
+on:
+ push:
+ branches:
+ - master
+ pull_request:
+ types: [opened, synchronize, reopened, ready_for_review]
+ merge_group:
+
+concurrency:
+ group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+ cancel-in-progress: true
+
+permissions: {}
+
+jobs:
+
+ preflight:
+ uses: ./.github/workflows/reusable-preflight.yml
+
+ cargo-clippy:
+ runs-on: ${{ needs.preflight.outputs.RUNNER }}
+ needs: [preflight]
+ # if: ${{ needs.preflight.outputs.changes_rust }}
+ timeout-minutes: 40
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ env:
+ RUSTFLAGS: "-D warnings"
+ SKIP_WASM_BUILD: 1
+ steps:
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
+ - name: script
+ run: |
+ forklift cargo clippy --all-targets --locked --workspace
+ forklift cargo clippy --all-targets --all-features --locked --workspace
+ check-try-runtime:
+ runs-on: ${{ needs.preflight.outputs.RUNNER }}
+ needs: [preflight]
+ # if: ${{ needs.preflight.outputs.changes_rust }}
+ timeout-minutes: 40
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ steps:
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
+ - name: script
+ run: |
+ forklift cargo check --locked --all --features try-runtime
+ # this is taken from cumulus
+ # Check that parachain-template will compile with `try-runtime` feature flag.
+ forklift cargo check --locked -p parachain-template-node --features try-runtime
+ # add after https://github.com/paritytech/substrate/pull/14502 is merged
+ # experimental code may rely on try-runtime and vice-versa
+ forklift cargo check --locked --all --features try-runtime,experimental
+ # check-core-crypto-features works fast without forklift
+ check-core-crypto-features:
+ runs-on: ${{ needs.preflight.outputs.RUNNER }}
+ needs: [preflight]
+ # if: ${{ needs.preflight.outputs.changes_rust }}
+ timeout-minutes: 30
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ steps:
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
+ - name: script
+ run: |
+ cd substrate/primitives/core
+ ./check-features-variants.sh
+ cd -
+ cd substrate/primitives/application-crypto
+ ./check-features-variants.sh
+ cd -
+ cd substrate/primitives/keyring
+ ./check-features-variants.sh
+ cd -
+ # name of this job must be unique across all workflows
+ # otherwise GitHub will mark all these jobs as required
+ confirm-required-checks-passed:
+ runs-on: ubuntu-latest
+ name: All checks passed
+ # If any new job gets added, be sure to add it to this array
+ needs: [cargo-clippy, check-try-runtime, check-core-crypto-features]
+ if: always() && !cancelled()
+ steps:
+ - run: |
+ tee resultfile <<< '${{ toJSON(needs) }}'
+ FAILURES=$(cat resultfile | grep '"result": "failure"' | wc -l)
+ if [ $FAILURES -gt 0 ]; then
+ echo "### At least one required job failed ❌" >> $GITHUB_STEP_SUMMARY
+ exit 1
+ else
+ echo '### Good job! All the required jobs passed 🚀' >> $GITHUB_STEP_SUMMARY
+ fi
diff --git a/.github/workflows/cmd-tests.yml b/.github/workflows/cmd-tests.yml
new file mode 100644
index 0000000000000000000000000000000000000000..37f1747d0b9eac72cf8e6c10534a8c31402cd905
--- /dev/null
+++ b/.github/workflows/cmd-tests.yml
@@ -0,0 +1,18 @@
+name: Command Bot Tests
+
+on:
+ pull_request:
+
+permissions:
+ contents: read
+
+concurrency:
+ group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+ cancel-in-progress: true
+
+jobs:
+ test:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - run: python3 .github/scripts/cmd/test_cmd.py
diff --git a/.github/workflows/cmd.yml b/.github/workflows/cmd.yml
new file mode 100644
index 0000000000000000000000000000000000000000..5498beb50ccb16740cd3c8eae09dd85fc0ff6206
--- /dev/null
+++ b/.github/workflows/cmd.yml
@@ -0,0 +1,455 @@
+name: Command
+
+on:
+ issue_comment: # listen for comments on issues
+ types: [created]
+
+permissions: # allow the action to comment on the PR
+ contents: write
+ issues: write
+ pull-requests: write
+ actions: read
+
+jobs:
+ is-org-member:
+ if: startsWith(github.event.comment.body, '/cmd')
+ runs-on: ubuntu-latest
+ outputs:
+ member: ${{ steps.is-member.outputs.result }}
+ steps:
+ - name: Generate token
+ id: generate_token
+ uses: tibdex/github-app-token@v2.1.0
+ with:
+ app_id: ${{ secrets.CMD_BOT_APP_ID }}
+ private_key: ${{ secrets.CMD_BOT_APP_KEY }}
+
+ - name: Check if user is a member of the organization
+ id: is-member
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ steps.generate_token.outputs.token }}
+ result-encoding: string
+ script: |
+ const fs = require("fs");
+ try {
+ const org = '${{ github.event.repository.owner.login }}';
+ const username = '${{ github.event.comment.user.login }}';
+
+ const membership = await github.rest.orgs.checkMembershipForUser({
+ org: org,
+ username: username
+ });
+
+ console.log(membership, membership.status, membership.status === 204);
+
+ if (membership.status === 204) {
+ return 'true';
+ } else {
+ console.log(membership);
+ fs.appendFileSync(process.env["GITHUB_STEP_SUMMARY"], `${membership.data && membership.data.message || 'Unknown error happened, please check logs'}`);
+ }
+ } catch (error) {
+ console.log(error)
+ }
+
+ return 'false';
+
+ reject-non-members:
+ needs: is-org-member
+ if: ${{ startsWith(github.event.comment.body, '/cmd') && needs.is-org-member.outputs.member != 'true' }}
+ runs-on: ubuntu-latest
+ steps:
+ - name: Add reaction to rejected comment
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.reactions.createForIssueComment({
+ comment_id: ${{ github.event.comment.id }},
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ content: 'confused'
+ })
+
+ - name: Comment PR (Rejected)
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: `Sorry, only members of the organization ${{ github.event.repository.owner.login }} members can run commands.`
+ })
+
+ acknowledge:
+ needs: is-org-member
+ if: ${{ startsWith(github.event.comment.body, '/cmd') && needs.is-org-member.outputs.member == 'true' }}
+ runs-on: ubuntu-latest
+ steps:
+ - name: Add reaction to triggered comment
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.reactions.createForIssueComment({
+ comment_id: ${{ github.event.comment.id }},
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ content: 'eyes'
+ })
+
+ clean:
+ needs: is-org-member
+ runs-on: ubuntu-latest
+ steps:
+ - name: Clean previous comments
+ if: ${{ startsWith(github.event.comment.body, '/cmd') && contains(github.event.comment.body, '--clean') && needs.is-org-member.outputs.member == 'true' }}
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.issues.listComments({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo
+ }).then(comments => {
+ for (let comment of comments.data) {
+ console.log(comment)
+ if (
+ ${{ github.event.comment.id }} !== comment.id &&
+ (
+ (
+ (
+ comment.body.startsWith('Command') ||
+ comment.body.startsWith('Command') ||
+ comment.body.startsWith('Sorry, only ')
+ ) && comment.user.type === 'Bot'
+ ) ||
+ (comment.body.startsWith('/cmd') && comment.user.login === context.actor)
+ )
+ ) {
+ github.rest.issues.deleteComment({
+ comment_id: comment.id,
+ owner: context.repo.owner,
+ repo: context.repo.repo
+ })
+ }
+ }
+ })
+ help:
+ needs: [clean, is-org-member]
+ if: ${{ startsWith(github.event.comment.body, '/cmd') && contains(github.event.comment.body, '--help') && needs.is-org-member.outputs.member == 'true' }}
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v4
+
+ - name: Get command
+ uses: actions-ecosystem/action-regex-match@v2
+ id: get-pr-comment
+ with:
+ text: ${{ github.event.comment.body }}
+ regex: '^(\/cmd )([-\/\s\w.=:]+)$' # see explanation in docs/contributor/commands-readme.md#examples
+
+ - name: Save output of help
+ id: help
+ env:
+ CMD: ${{ steps.get-pr-comment.outputs.group2 }} # to avoid "" around the command
+ run: |
+ echo 'help<> $GITHUB_OUTPUT
+ python3 -m pip install -r .github/scripts/generate-prdoc.requirements.txt
+ python3 .github/scripts/cmd/cmd.py $CMD >> $GITHUB_OUTPUT
+ echo 'EOF' >> $GITHUB_OUTPUT
+
+ - name: Comment PR (Help)
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: `Command help:
+
+ \`\`\`
+ ${{ steps.help.outputs.help }}
+ \`\`\`
+
+ > $GITHUB_OUTPUT
+
+ - name: Comment PR (End)
+ if: ${{ !failure() && !contains(github.event.comment.body, '--quiet') }}
+ uses: actions/github-script@v7
+ env:
+ SUBWEIGHT: "${{ steps.subweight.outputs.result }}"
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ let runUrl = ${{ steps.build-link.outputs.run_url }}
+ let subweight = process.env.SUBWEIGHT;
+
+ let subweightCollapsed = subweight
+ ? `\n\nSubweight results: \n\n${subweight}\n\n `
+ : '';
+
+ github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: `Command "${{ steps.get-pr-comment.outputs.group2 }}" has finished ✅ [See logs here](${runUrl})${subweightCollapsed}`
+ })
+
+ - name: Comment PR (Failure)
+ if: ${{ failure() && !contains(github.event.comment.body, '--quiet') }}
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ let jobUrl = ${{ steps.build-link.outputs.job_url }}
+ github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: `Command "${{ steps.get-pr-comment.outputs.group2 }}" has failed ❌! [See logs here](${jobUrl})`
+ })
+
+ - name: Add 😕 reaction on failure
+ uses: actions/github-script@v7
+ if: ${{ failure() }}
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.reactions.createForIssueComment({
+ comment_id: ${{ github.event.comment.id }},
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ content: 'confused'
+ })
+
+ - name: Add 👍 reaction on success
+ uses: actions/github-script@v7
+ if: ${{ !failure() }}
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.reactions.createForIssueComment({
+ comment_id: ${{ github.event.comment.id }},
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ content: '+1'
+ })
diff --git a/.github/workflows/command-backport.yml b/.github/workflows/command-backport.yml
new file mode 100644
index 0000000000000000000000000000000000000000..5b32f954d0cd2a45c7f6f3aba2eda8c2280605d4
--- /dev/null
+++ b/.github/workflows/command-backport.yml
@@ -0,0 +1,95 @@
+name: Backport into stable
+
+on:
+ # This trigger can be problematic, see: https://securitylab.github.com/resources/github-actions-preventing-pwn-requests/
+ # In our case it is fine since we only run it on merged Pull Requests and do not execute any of the repo code itself.
+ pull_request_target:
+ types: [ closed, labeled ]
+
+permissions:
+ contents: write # so it can comment
+ pull-requests: write # so it can create pull requests
+ issues: write
+
+jobs:
+ backport:
+ name: Backport pull request
+ runs-on: ubuntu-latest
+
+ # The 'github.event.pull_request.merged' ensures that it got into master:
+ if: >
+ ( !startsWith(github.event.pull_request.base.ref, 'stable') ) &&
+ (
+ github.event_name == 'pull_request_target' &&
+ github.event.pull_request.merged &&
+ github.event.pull_request.base.ref == 'master' &&
+ contains(github.event.pull_request.labels.*.name, 'A4-needs-backport')
+ )
+ steps:
+ - uses: actions/checkout@v4
+
+ - name: Generate token
+ id: generate_token
+ uses: tibdex/github-app-token@v2.1.0
+ with:
+ app_id: ${{ secrets.CMD_BOT_APP_ID }}
+ private_key: ${{ secrets.CMD_BOT_APP_KEY }}
+
+ - name: Create backport pull requests
+ uses: korthout/backport-action@v3
+ id: backport
+ with:
+ target_branches: stable2407 stable2409
+ merge_commits: skip
+ github_token: ${{ steps.generate_token.outputs.token }}
+ pull_description: |
+ Backport #${pull_number} into `${target_branch}` from ${pull_author}.
+
+ See the [documentation](https://github.com/paritytech/polkadot-sdk/blob/master/docs/BACKPORT.md) on how to use this bot.
+
+
+ pull_title: |
+ [${target_branch}] Backport #${pull_number}
+ experimental: >
+ {
+ "conflict_resolution": "draft_commit_conflicts"
+ }
+ copy_assignees: true
+
+ - name: Label Backports
+ if: ${{ steps.backport.outputs.created_pull_numbers != '' }}
+ uses: actions/github-script@v7
+ with:
+ script: |
+ const pullNumbers = '${{ steps.backport.outputs.created_pull_numbers }}'.split(' ');
+
+ for (const pullNumber of pullNumbers) {
+ await github.rest.issues.addLabels({
+ issue_number: parseInt(pullNumber),
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ labels: ['A3-backport']
+ });
+ console.log(`Added A3-backport label to PR #${pullNumber}`);
+ }
+
+ - name: Request Review
+ if: ${{ steps.backport.outputs.created_pull_numbers != '' }}
+ uses: actions/github-script@v7
+ with:
+ script: |
+ const pullNumbers = '${{ steps.backport.outputs.created_pull_numbers }}'.split(' ');
+ const reviewer = '${{ github.event.pull_request.user.login }}';
+
+ for (const pullNumber of pullNumbers) {
+ await github.pulls.createReviewRequest({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ pull_number: parseInt(pullNumber),
+ reviewers: [ reviewer ]
+ });
+ console.log(`Requested review from ${reviewer} for PR #${pullNumber}`);
+ }
diff --git a/.github/workflows/command-bench-all.yml b/.github/workflows/command-bench-all.yml
deleted file mode 100644
index 4128f86fb7c82f76e658fd39fad3365395a244e2..0000000000000000000000000000000000000000
--- a/.github/workflows/command-bench-all.yml
+++ /dev/null
@@ -1,99 +0,0 @@
-name: Command Bench All
-
-on:
- workflow_dispatch:
- inputs:
- pr:
- description: Number of the Pull Request
- required: true
- benchmark:
- description: Pallet benchmark
- type: choice
- required: true
- options:
- - pallet
- - substrate
- - polkadot
- - cumulus
- pallet:
- description: Pallet
- required: false
- type: string
- default: pallet_name
- target_dir:
- description: Target directory
- type: choice
- options:
- - substrate
- - polkadot
- - cumulus
- runtime:
- description: Runtime
- type: choice
- options:
- - rococo
- - westend
- - asset-hub-kusama
- - asset-hub-polkadot
- - asset-hub-rococo
- - asset-hub-westend
- - bridge-hub-kusama
- - bridge-hub-polkadot
- - bridge-hub-rococo
- - bridge-hub-westend
- - collectives-polkadot
- - collectives-westend
- - coretime-rococo
- - coretime-westend
- - contracts-rococo
- - glutton-kusama
- - glutton-westend
- - people-rococo
- - people-westend
-
-jobs:
- set-image:
- runs-on: ubuntu-latest
- outputs:
- IMAGE: ${{ steps.set_image.outputs.IMAGE }}
- steps:
- - name: Checkout
- uses: actions/checkout@v4
- - id: set_image
- run: cat .github/env >> $GITHUB_OUTPUT
- cmd-bench-all:
- needs: [set-image]
- runs-on: arc-runners-polkadot-sdk-weights
- container:
- image: ${{ needs.set-image.outputs.IMAGE }}
- permissions:
- contents: write
- pull-requests: write
- steps:
- - name: Download repo
- uses: actions/checkout@v4
- - name: Install gh cli
- id: gh
- uses: ./.github/actions/set-up-gh
- with:
- pr-number: ${{ inputs.pr }}
- GH_TOKEN: ${{ github.token }}
- - name: Run bench all
- run: |
- "./scripts/bench-all.sh" "${{ inputs.benchmark }}" --runtime "${{ inputs.runtime }}" --pallet "${{ inputs.pallet }}" --target_dir "${{ inputs.target_dir }}"
- - name: Report failure
- if: ${{ failure() }}
- run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
- - run: git pull --rebase
- - uses: stefanzweifel/git-auto-commit-action@v5
- with:
- commit_message: cmd-action - ${{ github.workflow }}
- branch: ${{ steps.gh.outputs.branch }}
- - name: Report succeed
- run: gh pr comment ${{ inputs.pr }} --body "Action completed 🎉🎉 Run by @${{ github.actor }} for ${{ github.workflow }} completed 🎉. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-bench-overhead.yml b/.github/workflows/command-bench-overhead.yml
deleted file mode 100644
index fec8d37bb9ef80505c9569da08071ccee7275067..0000000000000000000000000000000000000000
--- a/.github/workflows/command-bench-overhead.yml
+++ /dev/null
@@ -1,78 +0,0 @@
-name: Command Bench Overhead
-
-on:
- workflow_dispatch:
- inputs:
- pr:
- description: Number of the Pull Request
- required: true
- benchmark:
- description: Pallet benchmark
- type: choice
- required: true
- options:
- - default
- - substrate
- - cumulus
- runtime:
- description: Runtime
- type: choice
- options:
- - rococo
- - westend
- - asset-hub-rococo
- - asset-hub-westend
- target_dir:
- description: Target directory
- type: choice
- options:
- - polkadot
- - substrate
- - cumulus
-
-jobs:
- set-image:
- runs-on: ubuntu-latest
- outputs:
- IMAGE: ${{ steps.set_image.outputs.IMAGE }}
- steps:
- - name: Checkout
- uses: actions/checkout@v4
- - id: set_image
- run: cat .github/env >> $GITHUB_OUTPUT
- cmd-bench-overhead:
- needs: [set-image]
- runs-on: arc-runners-polkadot-sdk-benchmark
- container:
- image: ${{ needs.set-image.outputs.IMAGE }}
- permissions:
- contents: write
- pull-requests: write
- steps:
- - name: Download repo
- uses: actions/checkout@v4
- - name: Install gh cli
- id: gh
- uses: ./.github/actions/set-up-gh
- with:
- pr-number: ${{ inputs.pr }}
- GH_TOKEN: ${{ github.token }}
- - name: Run bench overhead
- run: |
- "./scripts/bench.sh" "${{ inputs.benchmark }}" --subcommand "overhead" --runtime "${{ inputs.runtime }}" --target_dir "${{ inputs.target_dir }}"
- - name: Report failure
- if: ${{ failure() }}
- run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
- - run: git pull --rebase
- - uses: stefanzweifel/git-auto-commit-action@v5
- with:
- commit_message: cmd-action - ${{ github.workflow }}
- branch: ${{ steps.gh.outputs.branch }}
- - name: Report succeed
- run: gh pr comment ${{ inputs.pr }} --body "Action completed 🎉🎉 Run by @${{ github.actor }} for ${{ github.workflow }} completed 🎉. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-bench.yml b/.github/workflows/command-bench.yml
deleted file mode 100644
index ac879f443755c65948c51f592dacc39ceb8f5c25..0000000000000000000000000000000000000000
--- a/.github/workflows/command-bench.yml
+++ /dev/null
@@ -1,124 +0,0 @@
-name: Command Bench
-
-on:
- workflow_dispatch:
- inputs:
- pr:
- description: Number of the Pull Request
- required: true
- benchmark:
- description: Pallet benchmark
- type: choice
- required: true
- options:
- - substrate-pallet
- - polkadot-pallet
- - cumulus-assets
- - cumulus-collectives
- - cumulus-coretime
- - cumulus-bridge-hubs
- - cumulus-contracts
- - cumulus-glutton
- - cumulus-starters
- - cumulus-people
- - cumulus-testing
- subcommand:
- description: Subcommand
- type: choice
- required: true
- options:
- - pallet
- - xcm
- runtime:
- description: Runtime
- type: choice
- options:
- - dev
- - rococo
- - westend
- - asset-hub-westend
- - asset-hub-rococo
- - collectives-westend
- - coretime-rococo
- - coretime-westend
- - bridge-hub-rococo
- - bridge-hub-westend
- - contracts-rococo
- - glutton-westend
- - glutton-westend-dev-1300
- - seedling
- - shell
- - people-westend
- - people-rococo
- - penpal
- - rococo-parachain
- pallet:
- description: Pallet
- type: string
- default: pallet_name
- target_dir:
- description: Target directory
- type: choice
- options:
- - substrate
- - polkadot
- - cumulus
- runtime_dir:
- description: Runtime directory
- type: choice
- options:
- - people
- - collectives
- - coretime
- - bridge-hubs
- - contracts
- - glutton
- - starters
- - testing
-
-jobs:
- set-image:
- runs-on: ubuntu-latest
- outputs:
- IMAGE: ${{ steps.set_image.outputs.IMAGE }}
- steps:
- - name: Checkout
- uses: actions/checkout@v4
- - id: set_image
- run: cat .github/env >> $GITHUB_OUTPUT
- cmd-bench:
- needs: [set-image]
- runs-on: arc-runners-polkadot-sdk-benchmark
- container:
- image: ${{ needs.set-image.outputs.IMAGE }}
- permissions:
- contents: write
- pull-requests: write
- steps:
- - name: Download repo
- uses: actions/checkout@v4
- - name: Install gh cli
- id: gh
- uses: ./.github/actions/set-up-gh
- with:
- pr-number: ${{ inputs.pr }}
- GH_TOKEN: ${{ github.token }}
- - name: Run bench
- run: |
- "./scripts/bench.sh" "${{ inputs.benchmark }}" --runtime "${{ inputs.runtime }}" --pallet "${{ inputs.pallet }}" --target_dir "${{ inputs.target_dir }}" --subcommand "${{ inputs.subcommand }}" --runtime_dir "${{ inputs.runtime_dir }}"
- - name: Report failure
- if: ${{ failure() }}
- run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
- - run: git pull --rebase
- - uses: stefanzweifel/git-auto-commit-action@v5
- with:
- commit_message: cmd-action - ${{ github.workflow }}
- branch: ${{ steps.gh.outputs.branch }}
- - name: Report succeed
- run: gh pr comment ${{ inputs.pr }} --body "Action completed 🎉🎉 Run by @${{ github.actor }} for ${{ github.workflow }} completed 🎉. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-fmt.yml b/.github/workflows/command-fmt.yml
deleted file mode 100644
index fc37a17ac549b06e6850ea8a209ec4b27db8fb3f..0000000000000000000000000000000000000000
--- a/.github/workflows/command-fmt.yml
+++ /dev/null
@@ -1,65 +0,0 @@
-name: Command FMT
-
-on:
- workflow_dispatch:
- inputs:
- pr:
- description: Number of the Pull Request
- required: true
-
-jobs:
- set-image:
- runs-on: ubuntu-latest
- outputs:
- IMAGE: ${{ steps.set_image.outputs.IMAGE }}
- steps:
- - name: Checkout
- uses: actions/checkout@v4
- - id: set_image
- run: cat .github/env >> $GITHUB_OUTPUT
- cmd-fmt:
- needs: [set-image]
- runs-on: ubuntu-latest
- timeout-minutes: 20
- container:
- image: ${{ needs.set-image.outputs.IMAGE }}
- permissions:
- contents: write
- pull-requests: write
- steps:
- - name: Download repo
- uses: actions/checkout@v4
- - name: Install gh cli
- id: gh
- uses: ./.github/actions/set-up-gh
- with:
- pr-number: ${{ inputs.pr }}
- GH_TOKEN: ${{ github.token }}
- - name: Run FMT
- run: |
- cargo --version
- rustc --version
- cargo +nightly --version
- rustc +nightly --version
-
- cargo +nightly fmt
-
- # format toml.
- # since paritytech/ci-unified:bullseye-1.73.0-2023-11-01-v20231204 includes taplo-cli
- taplo format --config .config/taplo.toml
- - name: Report failure
- if: ${{ failure() }}
- run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
- - run: git pull --rebase
- - uses: stefanzweifel/git-auto-commit-action@v5
- with:
- commit_message: cmd-action - ${{ github.workflow }}
- branch: ${{ steps.gh.outputs.branch }}
- - name: Report succeed
- run: gh pr comment ${{ inputs.pr }} --body "Action completed 🎉🎉 Run by @${{ github.actor }} for ${{ github.workflow }} completed 🎉. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-inform.yml b/.github/workflows/command-inform.yml
index 2825f4a604605fea8465ce0646d664c9ef5d38f5..97346395319362b0455bcbcfbb490fa23e6b3b07 100644
--- a/.github/workflows/command-inform.yml
+++ b/.github/workflows/command-inform.yml
@@ -2,20 +2,21 @@ name: Inform of new command action
on:
issue_comment:
- types: [created]
+ types: [ created ]
jobs:
comment:
runs-on: ubuntu-latest
- if: github.event.issue.pull_request && startsWith(github.event.comment.body, 'bot ')
+ # Temporary disable the bot until the new command bot works properly
+ if: github.event.issue.pull_request && startsWith(github.event.comment.body, 'bot ') && false # disabled for now, until tested
steps:
- - name: Inform that the new command exist
- uses: actions/github-script@v7
- with:
- script: |
- github.rest.issues.createComment({
- issue_number: context.issue.number,
- owner: context.repo.owner,
- repo: context.repo.repo,
- body: 'We are migrating the command bot to be a GitHub Actiondocumentation on how to use it '
- })
+ - name: Inform that the new command exist
+ uses: actions/github-script@v7
+ with:
+ script: |
+ github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: 'We have migrated the command bot to GHAhere . Soon the old commands will be disabled.'
+ })
\ No newline at end of file
diff --git a/.github/workflows/command-prdoc.yml b/.github/workflows/command-prdoc.yml
new file mode 100644
index 0000000000000000000000000000000000000000..aa9de9474a7b434deaab92821ab3b9bdad4b82e6
--- /dev/null
+++ b/.github/workflows/command-prdoc.yml
@@ -0,0 +1,84 @@
+name: Command PrDoc
+
+on:
+ workflow_dispatch:
+ inputs:
+ pr:
+ type: number
+ description: Number of the Pull Request
+ required: true
+ bump:
+ type: choice
+ description: Default bump level for all crates
+ default: "TODO"
+ required: true
+ options:
+ - "TODO"
+ - "no change"
+ - "patch"
+ - "minor"
+ - "major"
+ audience:
+ type: choice
+ description: Audience of the PrDoc
+ default: "TODO"
+ required: true
+ options:
+ - "TODO"
+ - "Runtime Dev"
+ - "Runtime User"
+ - "Node Dev"
+ - "Node User"
+ overwrite:
+ type: choice
+ description: Overwrite existing PrDoc
+ default: "true"
+ required: true
+ options:
+ - "true"
+ - "false"
+
+concurrency:
+ group: command-prdoc
+ cancel-in-progress: true
+
+jobs:
+ preflight:
+ uses: ./.github/workflows/reusable-preflight.yml
+
+ cmd-prdoc:
+ needs: [preflight]
+ runs-on: ubuntu-latest
+ timeout-minutes: 20
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ permissions:
+ contents: write
+ pull-requests: write
+ steps:
+ - name: Download repo
+ uses: actions/checkout@v4
+ - name: Install gh cli
+ id: gh
+ uses: ./.github/actions/set-up-gh
+ with:
+ pr-number: ${{ inputs.pr }}
+ GH_TOKEN: ${{ github.token }}
+ - name: Generate PrDoc
+ run: |
+ python3 -m pip install -q cargo-workspace PyGithub whatthepatch pyyaml toml
+
+ python3 .github/scripts/generate-prdoc.py --pr "${{ inputs.pr }}" --bump "${{ inputs.bump }}" --audience "${{ inputs.audience }}" --force "${{ inputs.overwrite }}"
+
+ - name: Report failure
+ if: ${{ failure() }}
+ run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
+ env:
+ RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+ GH_TOKEN: ${{ github.token }}
+ - name: Push Commit
+ uses: stefanzweifel/git-auto-commit-action@v5
+ with:
+ commit_message: Add PrDoc (auto generated)
+ branch: ${{ steps.gh.outputs.branch }}
+ file_pattern: 'prdoc/*.prdoc'
diff --git a/.github/workflows/command-sync.yml b/.github/workflows/command-sync.yml
deleted file mode 100644
index c610f4066a873e3fe7304bebd2f4b866fe837a91..0000000000000000000000000000000000000000
--- a/.github/workflows/command-sync.yml
+++ /dev/null
@@ -1,71 +0,0 @@
-name: Command Sync
-
-on:
- workflow_dispatch:
- inputs:
- pr:
- description: Number of the Pull Request
- required: true
- chain:
- description: Chain
- type: choice
- required: true
- options:
- - westend
- - rococo
- sync-type:
- description: Sync type
- type: choice
- required: true
- options:
- - warp
- - full
- - fast
- - fast-unsafe
-
-jobs:
- set-image:
- runs-on: ubuntu-latest
- outputs:
- IMAGE: ${{ steps.set_image.outputs.IMAGE }}
- steps:
- - name: Checkout
- uses: actions/checkout@v4
- - id: set_image
- run: cat .github/env >> $GITHUB_OUTPUT
- cmd-sync:
- needs: [set-image]
- runs-on: arc-runners-polkadot-sdk-warpsync
- container:
- image: ${{ needs.set-image.outputs.IMAGE }}
- permissions:
- contents: write
- pull-requests: write
- steps:
- - name: Download repo
- uses: actions/checkout@v4
- - name: Install gh cli
- id: gh
- uses: ./.github/actions/set-up-gh
- with:
- pr-number: ${{ inputs.pr }}
- GH_TOKEN: ${{ github.token }}
- - name: Run sync
- run: |
- "./scripts/sync.sh" --chain "${{ inputs.chain }}" --type "${{ inputs.sync-type }}"
- - name: Report failure
- if: ${{ failure() }}
- run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
- - run: git pull --rebase
- - uses: stefanzweifel/git-auto-commit-action@v5
- with:
- commit_message: cmd-action - ${{ github.workflow }}
- branch: ${{ steps.gh.outputs.branch }}
- - name: Report succeed
- run: gh pr comment ${{ inputs.pr }} --body "Action completed 🎉🎉 Run by @${{ github.actor }} for ${{ github.workflow }} completed 🎉. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-update-ui.yml b/.github/workflows/command-update-ui.yml
deleted file mode 100644
index 860177adc8790c28f7cd5873f4f8e0adf24a044f..0000000000000000000000000000000000000000
--- a/.github/workflows/command-update-ui.yml
+++ /dev/null
@@ -1,59 +0,0 @@
-name: Command Update UI
-
-on:
- workflow_dispatch:
- inputs:
- pr:
- description: Number of the Pull Request
- required: true
- rust-version:
- description: Version of rust. Example 1.70
- required: false
-
-jobs:
- set-image:
- runs-on: ubuntu-latest
- outputs:
- IMAGE: ${{ steps.set_image.outputs.IMAGE }}
- steps:
- - name: Checkout
- uses: actions/checkout@v4
- - id: set_image
- run: cat .github/env >> $GITHUB_OUTPUT
- cmd-update-ui:
- needs: [set-image]
- runs-on: arc-runners-polkadot-sdk-beefy
- timeout-minutes: 90
- container:
- image: ${{ needs.set-image.outputs.IMAGE }}
- permissions:
- contents: write
- pull-requests: write
- steps:
- - name: Download repo
- uses: actions/checkout@v4
- - name: Install gh cli
- id: gh
- uses: ./.github/actions/set-up-gh
- with:
- pr-number: ${{ inputs.pr }}
- GH_TOKEN: ${{ github.token }}
- - name: Run update-ui
- run: |
- "./scripts/update-ui-tests.sh" "${{ inputs.rust-version }}"
- - name: Report failure
- if: ${{ failure() }}
- run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
- - run: git pull --rebase
- - uses: stefanzweifel/git-auto-commit-action@v5
- with:
- commit_message: cmd-action - ${{ github.workflow }}
- branch: ${{ steps.gh.outputs.branch }}
- - name: Report succeed
- run: gh pr comment ${{ inputs.pr }} --body "Action completed 🎉🎉 Run by @${{ github.actor }} for ${{ github.workflow }} completed 🎉. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 0000000000000000000000000000000000000000..514bac3973bf76dbab6a8c246054400d3fb1c4e9
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,130 @@
+name: Docs
+
+on:
+ push:
+ branches:
+ - master
+ pull_request:
+ types: [opened, synchronize, reopened, ready_for_review, labeled]
+ merge_group:
+
+concurrency:
+ group: ${{ github.ref }}
+ cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
+
+jobs:
+ preflight:
+ uses: ./.github/workflows/reusable-preflight.yml
+
+ test-rustdoc:
+ runs-on: arc-runners-polkadot-sdk-beefy
+ needs: [preflight]
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ steps:
+ - uses: actions/checkout@v4
+ - run: forklift cargo doc --workspace --all-features --no-deps
+ env:
+ SKIP_WASM_BUILD: 1
+ test-doc:
+ runs-on: arc-runners-polkadot-sdk-beefy
+ needs: [preflight]
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ steps:
+ - uses: actions/checkout@v4
+ - run: forklift cargo test --doc --workspace
+ env:
+ RUSTFLAGS: "-Cdebug-assertions=y -Dwarnings"
+
+ build-rustdoc:
+ runs-on: arc-runners-polkadot-sdk-beefy
+ needs: [preflight, test-rustdoc]
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ steps:
+ - uses: actions/checkout@v4
+ - run: forklift cargo doc --all-features --workspace --no-deps
+ env:
+ SKIP_WASM_BUILD: 1
+ RUSTDOCFLAGS: "-Dwarnings --default-theme=ayu --html-in-header ./docs/sdk/assets/header.html --extend-css ./docs/sdk/assets/theme.css --html-after-content ./docs/sdk/assets/after-content.html"
+ - run: rm -f ./target/doc/.lock
+ - run: mv ./target/doc ./crate-docs
+ - name: Inject Simple Analytics script
+ run: |
+ script_content="(
- PhantomData<(T, RefPara, Priority, SlashAccount)>,
-);
-
-impl, SlashAccount: Get>
- BridgeRuntimeFilterCall
- for CheckAndBoostBridgeParachainsTransactions
+pub struct CheckAndBoostBridgeParachainsTransactions<
+ T,
+ ParachainsInstance,
+ Para,
+ Priority,
+ SlashAccount,
+>(PhantomData<(T, ParachainsInstance, Para, Priority, SlashAccount)>);
+
+impl<
+ T,
+ ParachainsInstance,
+ Para,
+ Priority: Get,
+ SlashAccount: Get,
+ > BridgeRuntimeFilterCall
+ for CheckAndBoostBridgeParachainsTransactions
where
- T: pallet_bridge_relayers::Config + pallet_bridge_parachains::Config,
- RefPara: RefundableParachainId,
- T::RuntimeCall: ParachainsCallSubtype,
+ T: pallet_bridge_relayers::Config + pallet_bridge_parachains::Config,
+ ParachainsInstance: 'static,
+ Para: Parachain,
+ T::RuntimeCall: ParachainsCallSubtype,
{
// bridged header number, bundled in transaction
type ToPostDispatch = Option;
@@ -145,10 +152,10 @@ where
who: &T::AccountId,
call: &T::RuntimeCall,
) -> (Self::ToPostDispatch, TransactionValidity) {
- match ParachainsCallSubtype::::check_obsolete_submit_parachain_heads(
+ match ParachainsCallSubtype::::check_obsolete_submit_parachain_heads(
call,
) {
- Ok(Some(our_tx)) if our_tx.base.para_id.0 == RefPara::BridgedChain::PARACHAIN_ID => {
+ Ok(Some(our_tx)) if our_tx.base.para_id.0 == Para::PARACHAIN_ID => {
let to_post_dispatch = Some(our_tx.base);
let total_priority_boost =
compute_priority_boost::(&who, our_tx.improved_by);
@@ -167,7 +174,7 @@ where
let Some(update) = maybe_update else { return };
// we are only interested in failed or unneeded transactions
let has_failed = has_failed ||
- !SubmitParachainHeadsHelper::::was_successful(&update);
+ !SubmitParachainHeadsHelper::::was_successful(&update);
if !has_failed {
return
@@ -275,7 +282,7 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
type Pre = (
$account_id,
( $(
- <$filter_call as $crate::extensions::check_obsolete_extension::BridgeRuntimeFilterCall<
+ <$filter_call as $crate::extensions::BridgeRuntimeFilterCall<
$account_id,
$call,
>>::ToPostDispatch,
@@ -302,7 +309,7 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
$(
let (from_validate, call_filter_validity) = <
$filter_call as
- $crate::extensions::check_obsolete_extension::BridgeRuntimeFilterCall<
+ $crate::extensions::BridgeRuntimeFilterCall<
Self::AccountId,
$call,
>>::validate(&who, call);
@@ -319,12 +326,13 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
info: &sp_runtime::traits::DispatchInfoOf,
len: usize,
) -> Result {
- use $crate::extensions::check_obsolete_extension::__private::tuplex::PushBack;
+ use $crate::extensions::__private::tuplex::PushBack;
+
let to_post_dispatch = ();
$(
let (from_validate, call_filter_validity) = <
$filter_call as
- $crate::extensions::check_obsolete_extension::BridgeRuntimeFilterCall<
+ $crate::extensions::BridgeRuntimeFilterCall<
$account_id,
$call,
>>::validate(&relayer, call);
@@ -342,14 +350,15 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
len: usize,
result: &sp_runtime::DispatchResult,
) -> Result<(), sp_runtime::transaction_validity::TransactionValidityError> {
- use $crate::extensions::check_obsolete_extension::__private::tuplex::PopFront;
+ use $crate::extensions::__private::tuplex::PopFront;
+
let Some((relayer, to_post_dispatch)) = to_post_dispatch else { return Ok(()) };
let has_failed = result.is_err();
$(
let (item, to_post_dispatch) = to_post_dispatch.pop_front();
<
$filter_call as
- $crate::extensions::check_obsolete_extension::BridgeRuntimeFilterCall<
+ $crate::extensions::BridgeRuntimeFilterCall<
$account_id,
$call,
>>::post_dispatch(&relayer, has_failed, item);
@@ -363,25 +372,37 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
#[cfg(test)]
mod tests {
use super::*;
- use crate::{
- extensions::refund_relayer_extension::{
- tests::{
- initialize_environment, relayer_account_at_this_chain,
- submit_parachain_head_call_ex, submit_relay_header_call_ex,
- },
- RefundableParachain,
- },
- mock::*,
- };
- use bp_polkadot_core::parachains::ParaId;
+ use crate::mock::*;
+ use bp_header_chain::StoredHeaderDataBuilder;
+ use bp_messages::{InboundLaneData, LaneId, MessageNonce, OutboundLaneData};
+ use bp_parachains::{BestParaHeadHash, ParaInfo};
+ use bp_polkadot_core::parachains::{ParaHeadsProof, ParaId};
+ use bp_relayers::{RewardsAccountOwner, RewardsAccountParams};
use bp_runtime::HeaderId;
- use frame_support::{assert_err, assert_ok};
+ use bp_test_utils::{make_default_justification, test_keyring, TEST_GRANDPA_SET_ID};
+ use frame_support::{assert_err, assert_ok, traits::fungible::Mutate};
+ use pallet_bridge_grandpa::{Call as GrandpaCall, StoredAuthoritySet};
+ use pallet_bridge_parachains::Call as ParachainsCall;
use sp_runtime::{
- traits::{ConstU64, SignedExtension},
+ traits::{parameter_types, ConstU64, Header as _, SignedExtension},
transaction_validity::{InvalidTransaction, TransactionValidity, ValidTransaction},
DispatchError,
};
+ parameter_types! {
+ pub MsgProofsRewardsAccount: RewardsAccountParams = RewardsAccountParams::new(
+ test_lane_id(),
+ TEST_BRIDGED_CHAIN_ID,
+ RewardsAccountOwner::ThisChain,
+ );
+ pub MsgDeliveryProofsRewardsAccount: RewardsAccountParams = RewardsAccountParams::new(
+ test_lane_id(),
+ TEST_BRIDGED_CHAIN_ID,
+ RewardsAccountOwner::BridgedChain,
+ );
+ pub TestLaneId: LaneId = test_lane_id();
+ }
+
pub struct MockCall {
data: u32,
}
@@ -455,6 +476,103 @@ mod tests {
}
}
+ fn test_lane_id() -> LaneId {
+ LaneId::new(1, 2)
+ }
+
+ fn initial_balance_of_relayer_account_at_this_chain() -> ThisChainBalance {
+ let test_stake: ThisChainBalance = TestStake::get();
+ ExistentialDeposit::get().saturating_add(test_stake * 100)
+ }
+
+ // in tests, the following accounts are equal (because of how `into_sub_account_truncating`
+ // works)
+
+ fn delivery_rewards_account() -> ThisChainAccountId {
+ TestPaymentProcedure::rewards_account(MsgProofsRewardsAccount::get())
+ }
+
+ fn confirmation_rewards_account() -> ThisChainAccountId {
+ TestPaymentProcedure::rewards_account(MsgDeliveryProofsRewardsAccount::get())
+ }
+
+ fn relayer_account_at_this_chain() -> ThisChainAccountId {
+ 0
+ }
+
+ fn initialize_environment(
+ best_relay_header_number: BridgedChainBlockNumber,
+ parachain_head_at_relay_header_number: BridgedChainBlockNumber,
+ best_message: MessageNonce,
+ ) {
+ let authorities = test_keyring().into_iter().map(|(a, w)| (a.into(), w)).collect();
+ let best_relay_header = HeaderId(best_relay_header_number, BridgedChainHash::default());
+ pallet_bridge_grandpa::CurrentAuthoritySet::::put(
+ StoredAuthoritySet::try_new(authorities, TEST_GRANDPA_SET_ID).unwrap(),
+ );
+ pallet_bridge_grandpa::BestFinalized::::put(best_relay_header);
+ pallet_bridge_grandpa::ImportedHeaders::::insert(
+ best_relay_header.hash(),
+ bp_test_utils::test_header::(0).build(),
+ );
+
+ let para_id = ParaId(BridgedUnderlyingParachain::PARACHAIN_ID);
+ let para_info = ParaInfo {
+ best_head_hash: BestParaHeadHash {
+ at_relay_block_number: parachain_head_at_relay_header_number,
+ head_hash: [parachain_head_at_relay_header_number as u8; 32].into(),
+ },
+ next_imported_hash_position: 0,
+ };
+ pallet_bridge_parachains::ParasInfo::::insert(para_id, para_info);
+
+ let lane_id = test_lane_id();
+ let in_lane_data =
+ InboundLaneData { last_confirmed_nonce: best_message, ..Default::default() };
+ pallet_bridge_messages::InboundLanes::::insert(lane_id, in_lane_data);
+
+ let out_lane_data =
+ OutboundLaneData { latest_received_nonce: best_message, ..Default::default() };
+ pallet_bridge_messages::OutboundLanes::::insert(lane_id, out_lane_data);
+
+ Balances::mint_into(&delivery_rewards_account(), ExistentialDeposit::get()).unwrap();
+ Balances::mint_into(&confirmation_rewards_account(), ExistentialDeposit::get()).unwrap();
+ Balances::mint_into(
+ &relayer_account_at_this_chain(),
+ initial_balance_of_relayer_account_at_this_chain(),
+ )
+ .unwrap();
+ }
+
+ fn submit_relay_header_call(relay_header_number: BridgedChainBlockNumber) -> RuntimeCall {
+ let relay_header = BridgedChainHeader::new(
+ relay_header_number,
+ Default::default(),
+ Default::default(),
+ Default::default(),
+ Default::default(),
+ );
+ let relay_justification = make_default_justification(&relay_header);
+
+ RuntimeCall::BridgeGrandpa(GrandpaCall::submit_finality_proof {
+ finality_target: Box::new(relay_header),
+ justification: relay_justification,
+ })
+ }
+
+ fn submit_parachain_head_call(
+ parachain_head_at_relay_header_number: BridgedChainBlockNumber,
+ ) -> RuntimeCall {
+ RuntimeCall::BridgeParachains(ParachainsCall::submit_parachain_heads {
+ at_relay_block: (parachain_head_at_relay_header_number, BridgedChainHash::default()),
+ parachains: vec![(
+ ParaId(BridgedUnderlyingParachain::PARACHAIN_ID),
+ [parachain_head_at_relay_header_number as u8; 32].into(),
+ )],
+ parachain_heads_proof: ParaHeadsProof { storage_proof: Default::default() },
+ })
+ }
+
#[test]
fn test_generated_obsolete_extension() {
generate_bridge_reject_obsolete_headers_and_messages!(
@@ -546,7 +664,7 @@ mod tests {
let priority_boost = BridgeGrandpaWrapper::validate(
&relayer_account_at_this_chain(),
- &submit_relay_header_call_ex(200),
+ &submit_relay_header_call(200),
)
.1
.unwrap()
@@ -564,7 +682,7 @@ mod tests {
let priority_boost = BridgeGrandpaWrapper::validate(
&relayer_account_at_this_chain(),
- &submit_relay_header_call_ex(200),
+ &submit_relay_header_call(200),
)
.1
.unwrap()
@@ -601,7 +719,8 @@ mod tests {
type BridgeParachainsWrapper = CheckAndBoostBridgeParachainsTransactions<
TestRuntime,
- RefundableParachain<(), BridgedUnderlyingParachain>,
+ (),
+ BridgedUnderlyingParachain,
ConstU64<1_000>,
SlashDestination,
>;
@@ -613,7 +732,7 @@ mod tests {
let priority_boost = BridgeParachainsWrapper::validate(
&relayer_account_at_this_chain(),
- &submit_parachain_head_call_ex(200),
+ &submit_parachain_head_call(200),
)
.1
.unwrap()
@@ -631,7 +750,7 @@ mod tests {
let priority_boost = BridgeParachainsWrapper::validate(
&relayer_account_at_this_chain(),
- &submit_parachain_head_call_ex(200),
+ &submit_parachain_head_call(200),
)
.1
.unwrap()
diff --git a/bridges/bin/runtime-common/src/integrity.rs b/bridges/bin/runtime-common/src/integrity.rs
index a0a9367dd1400309d0f0be967665a4543ad982cb..2ff6c4c9165aade8899bc4d8fea47da43f59ec8b 100644
--- a/bridges/bin/runtime-common/src/integrity.rs
+++ b/bridges/bin/runtime-common/src/integrity.rs
@@ -68,21 +68,21 @@ macro_rules! assert_bridge_messages_pallet_types(
bridged_chain: $bridged:path,
) => {
{
- use $crate::messages_xcm_extension::XcmAsPlainPayload;
+ use $crate::integrity::__private::bp_xcm_bridge_hub::XcmAsPlainPayload;
use $crate::integrity::__private::static_assertions::assert_type_eq_all;
use bp_messages::ChainWithMessages;
use bp_runtime::Chain;
- use pallet_bridge_messages::Config as MessagesConfig;
+ use pallet_bridge_messages::Config as BridgeMessagesConfig;
// if one of asserts fail, then either bridge isn't configured properly (or alternatively - non-standard
// configuration is used), or something has broke existing configuration (meaning that all bridged chains
// and relays will stop functioning)
- 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 BridgeMessagesConfig<$i>>::ThisChain, $this);
+ assert_type_eq_all!(<$r as BridgeMessagesConfig<$i>>::BridgedChain, $bridged);
- assert_type_eq_all!(<$r as MessagesConfig<$i>>::OutboundPayload, XcmAsPlainPayload);
- assert_type_eq_all!(<$r as MessagesConfig<$i>>::InboundPayload, XcmAsPlainPayload);
+ assert_type_eq_all!(<$r as BridgeMessagesConfig<$i>>::OutboundPayload, XcmAsPlainPayload);
+ assert_type_eq_all!(<$r as BridgeMessagesConfig<$i>>::InboundPayload, XcmAsPlainPayload);
}
}
);
@@ -174,12 +174,6 @@ where
R: pallet_bridge_messages::Config,
MI: 'static,
{
- assert!(
- !R::ActiveOutboundLanes::get().is_empty(),
- "ActiveOutboundLanes ({:?}) must not be empty",
- R::ActiveOutboundLanes::get(),
- );
-
assert!(
pallet_bridge_messages::BridgedChainOf::::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX
<= pallet_bridge_messages::BridgedChainOf::::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
diff --git a/bridges/bin/runtime-common/src/lib.rs b/bridges/bin/runtime-common/src/lib.rs
index b65bb6041d5610ce2bdfb63f923f3f24b21dcd7f..ac8b013086b1bd63da2ed2e14d40002341be1758 100644
--- a/bridges/bin/runtime-common/src/lib.rs
+++ b/bridges/bin/runtime-common/src/lib.rs
@@ -20,16 +20,11 @@
#![cfg_attr(not(feature = "std"), no_std)]
pub mod extensions;
-
pub mod messages_api;
pub mod messages_benchmarking;
-pub mod messages_call_ext;
-pub mod messages_xcm_extension;
pub mod parachains_benchmarking;
mod mock;
#[cfg(feature = "integrity-test")]
pub mod integrity;
-
-const LOG_TARGET_BRIDGE_DISPATCH: &str = "runtime::bridge-dispatch";
diff --git a/bridges/bin/runtime-common/src/messages_xcm_extension.rs b/bridges/bin/runtime-common/src/messages_xcm_extension.rs
deleted file mode 100644
index 46ed4da0d85481fcc7223740084945924f9c710f..0000000000000000000000000000000000000000
--- a/bridges/bin/runtime-common/src/messages_xcm_extension.rs
+++ /dev/null
@@ -1,502 +0,0 @@
-// Copyright (C) Parity Technologies (UK) Ltd.
-// This file is part of Parity Bridges Common.
-
-// Parity Bridges Common is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity Bridges Common is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity Bridges Common. If not, see ),
-}
-
-/// [`XcmBlobMessageDispatch`] is responsible for dispatching received messages
-///
-/// It needs to be used at the target bridge hub.
-pub struct XcmBlobMessageDispatch {
- _marker: sp_std::marker::PhantomData<(DispatchBlob, Weights, Channel)>,
-}
-
-impl<
- BlobDispatcher: DispatchBlob,
- Weights: MessagesPalletWeights,
- Channel: XcmChannelStatusProvider,
- > MessageDispatch for XcmBlobMessageDispatch
-{
- type DispatchPayload = XcmAsPlainPayload;
- type DispatchLevelResult = XcmBlobMessageDispatchResult;
-
- fn is_active() -> bool {
- !Channel::is_congested()
- }
-
- fn dispatch_weight(message: &mut DispatchMessage) -> Weight {
- match message.data.payload {
- Ok(ref payload) => {
- let payload_size = payload.encoded_size().saturated_into();
- Weights::message_dispatch_weight(payload_size)
- },
- Err(_) => Weight::zero(),
- }
- }
-
- fn dispatch(
- message: DispatchMessage,
- ) -> MessageDispatchResult {
- let payload = match message.data.payload {
- Ok(payload) => payload,
- Err(e) => {
- log::error!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "[XcmBlobMessageDispatch] payload error: {:?} - message_nonce: {:?}",
- e,
- message.key.nonce
- );
- return MessageDispatchResult {
- unspent_weight: Weight::zero(),
- dispatch_level_result: XcmBlobMessageDispatchResult::InvalidPayload,
- }
- },
- };
- let dispatch_level_result = match BlobDispatcher::dispatch_blob(payload) {
- Ok(_) => {
- log::debug!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "[XcmBlobMessageDispatch] DispatchBlob::dispatch_blob was ok - message_nonce: {:?}",
- message.key.nonce
- );
- XcmBlobMessageDispatchResult::Dispatched
- },
- Err(e) => {
- log::error!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "[XcmBlobMessageDispatch] DispatchBlob::dispatch_blob failed, error: {:?} - message_nonce: {:?}",
- e, message.key.nonce
- );
- XcmBlobMessageDispatchResult::NotDispatched(Some(e))
- },
- };
- MessageDispatchResult { unspent_weight: Weight::zero(), dispatch_level_result }
- }
-}
-
-/// A pair of sending chain location and message lane, used by this chain to send messages
-/// over the bridge.
-#[cfg_attr(feature = "std", derive(Debug, Eq, PartialEq))]
-pub struct SenderAndLane {
- /// Sending chain relative location.
- pub location: Location,
- /// Message lane, used by the sending chain.
- pub lane: LaneId,
-}
-
-impl SenderAndLane {
- /// Create new object using provided location and lane.
- pub fn new(location: Location, lane: LaneId) -> Self {
- SenderAndLane { location, lane }
- }
-}
-
-/// [`XcmBlobHauler`] is responsible for sending messages to the bridge "point-to-point link" from
-/// one side, where on the other it can be dispatched by [`XcmBlobMessageDispatch`].
-pub trait XcmBlobHauler {
- /// Runtime that has messages pallet deployed.
- type Runtime: MessagesConfig;
- /// Instance of the messages pallet that is used to send messages.
- type MessagesInstance: 'static;
-
- /// Actual XCM message sender (`HRMP` or `UMP`) to the source chain
- /// location (`Self::SenderAndLane::get().location`).
- type ToSourceChainSender: SendXcm;
- /// An XCM message that is sent to the sending chain when the bridge queue becomes congested.
- type CongestedMessage: Get>>;
- /// An XCM message that is sent to the sending chain when the bridge queue becomes not
- /// congested.
- type UncongestedMessage: Get>>;
-
- /// Returns `true` if we want to handle congestion.
- fn supports_congestion_detection() -> bool {
- Self::CongestedMessage::get().is_some() || Self::UncongestedMessage::get().is_some()
- }
-}
-
-/// XCM bridge adapter which connects [`XcmBlobHauler`] with [`pallet_bridge_messages`] and
-/// makes sure that XCM blob is sent to the outbound lane to be relayed.
-///
-/// It needs to be used at the source bridge hub.
-pub struct XcmBlobHaulerAdapter(
- sp_std::marker::PhantomData<(XcmBlobHauler, Lanes)>,
-);
-
-impl<
- H: XcmBlobHauler,
- Lanes: Get>,
- > OnMessagesDelivered for XcmBlobHaulerAdapter
-{
- fn on_messages_delivered(lane: LaneId, enqueued_messages: MessageNonce) {
- if let Some(sender_and_lane) =
- Lanes::get().iter().find(|link| link.0.lane == lane).map(|link| &link.0)
- {
- // notify XCM queue manager about updated lane state
- LocalXcmQueueManager::::on_bridge_messages_delivered(
- sender_and_lane,
- enqueued_messages,
- );
- }
- }
-}
-
-/// Manager of local XCM queues (and indirectly - underlying transport channels) that
-/// controls the queue state.
-///
-/// It needs to be used at the source bridge hub.
-pub struct LocalXcmQueueManager(PhantomData);
-
-/// Maximal number of messages in the outbound bridge queue. Once we reach this limit, we
-/// send a "congestion" XCM message to the sending chain.
-const OUTBOUND_LANE_CONGESTED_THRESHOLD: MessageNonce = 8_192;
-
-/// After we have sent "congestion" XCM message to the sending chain, we wait until number
-/// of messages in the outbound bridge queue drops to this count, before sending `uncongestion`
-/// XCM message.
-const OUTBOUND_LANE_UNCONGESTED_THRESHOLD: MessageNonce = 1_024;
-
-impl LocalXcmQueueManager {
- /// Must be called whenever we push a message to the bridge lane.
- pub fn on_bridge_message_enqueued(
- sender_and_lane: &SenderAndLane,
- enqueued_messages: MessageNonce,
- ) {
- // skip if we dont want to handle congestion
- if !H::supports_congestion_detection() {
- return
- }
-
- // if we have already sent the congestion signal, we don't want to do anything
- if Self::is_congested_signal_sent(sender_and_lane.lane) {
- return
- }
-
- // if the bridge queue is not congested, we don't want to do anything
- let is_congested = enqueued_messages > OUTBOUND_LANE_CONGESTED_THRESHOLD;
- if !is_congested {
- return
- }
-
- log::info!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "Sending 'congested' XCM message to {:?} to avoid overloading lane {:?}: there are\
- {} messages queued at the bridge queue",
- sender_and_lane.location,
- sender_and_lane.lane,
- enqueued_messages,
- );
-
- if let Err(e) = Self::send_congested_signal(sender_and_lane) {
- log::info!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "Failed to send the 'congested' XCM message to {:?}: {:?}",
- sender_and_lane.location,
- e,
- );
- }
- }
-
- /// Must be called whenever we receive a message delivery confirmation.
- pub fn on_bridge_messages_delivered(
- sender_and_lane: &SenderAndLane,
- enqueued_messages: MessageNonce,
- ) {
- // skip if we don't want to handle congestion
- if !H::supports_congestion_detection() {
- return
- }
-
- // if we have not sent the congestion signal before, we don't want to do anything
- if !Self::is_congested_signal_sent(sender_and_lane.lane) {
- return
- }
-
- // if the bridge queue is still congested, we don't want to do anything
- let is_congested = enqueued_messages > OUTBOUND_LANE_UNCONGESTED_THRESHOLD;
- if is_congested {
- return
- }
-
- log::info!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "Sending 'uncongested' XCM message to {:?}. Lane {:?}: there are\
- {} messages queued at the bridge queue",
- sender_and_lane.location,
- sender_and_lane.lane,
- enqueued_messages,
- );
-
- if let Err(e) = Self::send_uncongested_signal(sender_and_lane) {
- log::info!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "Failed to send the 'uncongested' XCM message to {:?}: {:?}",
- sender_and_lane.location,
- e,
- );
- }
- }
-
- /// Returns true if we have sent "congested" signal to the `sending_chain_location`.
- fn is_congested_signal_sent(lane: LaneId) -> bool {
- OutboundLanesCongestedSignals::::get(lane)
- }
-
- /// Send congested signal to the `sending_chain_location`.
- fn send_congested_signal(sender_and_lane: &SenderAndLane) -> Result<(), SendError> {
- if let Some(msg) = H::CongestedMessage::get() {
- send_xcm::(sender_and_lane.location.clone(), msg)?;
- OutboundLanesCongestedSignals::::insert(
- sender_and_lane.lane,
- true,
- );
- }
- Ok(())
- }
-
- /// Send `uncongested` signal to the `sending_chain_location`.
- fn send_uncongested_signal(sender_and_lane: &SenderAndLane) -> Result<(), SendError> {
- if let Some(msg) = H::UncongestedMessage::get() {
- send_xcm::(sender_and_lane.location.clone(), msg)?;
- OutboundLanesCongestedSignals::::remove(
- sender_and_lane.lane,
- );
- }
- Ok(())
- }
-}
-
-/// Adapter for the implementation of `GetVersion`, which attempts to find the minimal
-/// configured XCM version between the destination `dest` and the bridge hub location provided as
-/// `Get`.
-pub struct XcmVersionOfDestAndRemoteBridge(
- sp_std::marker::PhantomData<(Version, RemoteBridge)>,
-);
-impl> GetVersion
- for XcmVersionOfDestAndRemoteBridge
-{
- fn get_version_for(dest: &Location) -> Option {
- let dest_version = Version::get_version_for(dest);
- let bridge_hub_version = Version::get_version_for(&RemoteBridge::get());
-
- match (dest_version, bridge_hub_version) {
- (Some(dv), Some(bhv)) => Some(sp_std::cmp::min(dv, bhv)),
- (Some(dv), None) => Some(dv),
- (None, Some(bhv)) => Some(bhv),
- (None, None) => None,
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::mock::*;
-
- use bp_messages::OutboundLaneData;
- use frame_support::parameter_types;
- use pallet_bridge_messages::OutboundLanes;
-
- parameter_types! {
- pub TestSenderAndLane: SenderAndLane = SenderAndLane {
- location: Location::new(1, [Parachain(1000)]),
- lane: TEST_LANE_ID,
- };
- pub TestLanes: sp_std::vec::Vec<(SenderAndLane, (NetworkId, InteriorLocation))> = sp_std::vec![
- (TestSenderAndLane::get(), (NetworkId::ByGenesis([0; 32]), InteriorLocation::Here))
- ];
- pub DummyXcmMessage: Xcm<()> = Xcm::new();
- }
-
- struct DummySendXcm;
-
- impl DummySendXcm {
- fn messages_sent() -> u32 {
- frame_support::storage::unhashed::get(b"DummySendXcm").unwrap_or(0)
- }
- }
-
- impl SendXcm for DummySendXcm {
- type Ticket = ();
-
- fn validate(
- _destination: &mut Option,
- _message: &mut Option>,
- ) -> SendResult {
- Ok(((), Default::default()))
- }
-
- fn deliver(_ticket: Self::Ticket) -> Result {
- let messages_sent: u32 = Self::messages_sent();
- frame_support::storage::unhashed::put(b"DummySendXcm", &(messages_sent + 1));
- Ok(XcmHash::default())
- }
- }
-
- struct TestBlobHauler;
-
- impl XcmBlobHauler for TestBlobHauler {
- type Runtime = TestRuntime;
- type MessagesInstance = ();
-
- type ToSourceChainSender = DummySendXcm;
- type CongestedMessage = DummyXcmMessage;
- type UncongestedMessage = DummyXcmMessage;
- }
-
- type TestBlobHaulerAdapter = XcmBlobHaulerAdapter;
-
- fn fill_up_lane_to_congestion() -> MessageNonce {
- let latest_generated_nonce = OUTBOUND_LANE_CONGESTED_THRESHOLD;
- OutboundLanes::::insert(
- TEST_LANE_ID,
- OutboundLaneData {
- oldest_unpruned_nonce: 0,
- latest_received_nonce: 0,
- latest_generated_nonce,
- },
- );
- latest_generated_nonce
- }
-
- #[test]
- fn congested_signal_is_not_sent_twice() {
- run_test(|| {
- let enqueued = fill_up_lane_to_congestion();
-
- // next sent message leads to congested signal
- LocalXcmQueueManager::::on_bridge_message_enqueued(
- &TestSenderAndLane::get(),
- enqueued + 1,
- );
- assert_eq!(DummySendXcm::messages_sent(), 1);
-
- // next sent message => we don't sent another congested signal
- LocalXcmQueueManager::::on_bridge_message_enqueued(
- &TestSenderAndLane::get(),
- enqueued,
- );
- assert_eq!(DummySendXcm::messages_sent(), 1);
- });
- }
-
- #[test]
- fn congested_signal_is_not_sent_when_outbound_lane_is_not_congested() {
- run_test(|| {
- LocalXcmQueueManager::::on_bridge_message_enqueued(
- &TestSenderAndLane::get(),
- 1,
- );
- assert_eq!(DummySendXcm::messages_sent(), 0);
- });
- }
-
- #[test]
- fn congested_signal_is_sent_when_outbound_lane_is_congested() {
- run_test(|| {
- let enqueued = fill_up_lane_to_congestion();
-
- // next sent message leads to congested signal
- LocalXcmQueueManager::::on_bridge_message_enqueued(
- &TestSenderAndLane::get(),
- enqueued + 1,
- );
- assert_eq!(DummySendXcm::messages_sent(), 1);
- assert!(LocalXcmQueueManager::::is_congested_signal_sent(TEST_LANE_ID));
- });
- }
-
- #[test]
- fn uncongested_signal_is_not_sent_when_messages_are_delivered_at_other_lane() {
- run_test(|| {
- LocalXcmQueueManager::::send_congested_signal(&TestSenderAndLane::get()).unwrap();
- assert_eq!(DummySendXcm::messages_sent(), 1);
-
- // when we receive a delivery report for other lane, we don't send an uncongested signal
- TestBlobHaulerAdapter::on_messages_delivered(LaneId([42, 42, 42, 42]), 0);
- assert_eq!(DummySendXcm::messages_sent(), 1);
- });
- }
-
- #[test]
- fn uncongested_signal_is_not_sent_when_we_havent_send_congested_signal_before() {
- run_test(|| {
- TestBlobHaulerAdapter::on_messages_delivered(TEST_LANE_ID, 0);
- assert_eq!(DummySendXcm::messages_sent(), 0);
- });
- }
-
- #[test]
- fn uncongested_signal_is_not_sent_if_outbound_lane_is_still_congested() {
- run_test(|| {
- LocalXcmQueueManager::::send_congested_signal(&TestSenderAndLane::get()).unwrap();
- assert_eq!(DummySendXcm::messages_sent(), 1);
-
- TestBlobHaulerAdapter::on_messages_delivered(
- TEST_LANE_ID,
- OUTBOUND_LANE_UNCONGESTED_THRESHOLD + 1,
- );
- assert_eq!(DummySendXcm::messages_sent(), 1);
- });
- }
-
- #[test]
- fn uncongested_signal_is_sent_if_outbound_lane_is_uncongested() {
- run_test(|| {
- LocalXcmQueueManager::::send_congested_signal(&TestSenderAndLane::get()).unwrap();
- assert_eq!(DummySendXcm::messages_sent(), 1);
-
- TestBlobHaulerAdapter::on_messages_delivered(
- TEST_LANE_ID,
- OUTBOUND_LANE_UNCONGESTED_THRESHOLD,
- );
- assert_eq!(DummySendXcm::messages_sent(), 2);
- });
- }
-}
diff --git a/bridges/bin/runtime-common/src/mock.rs b/bridges/bin/runtime-common/src/mock.rs
index 2f248a7162a6cbdcc09d2980a922b1a065127e40..fed0d15cc080b78381d3e2ad6bfe8a768139101d 100644
--- a/bridges/bin/runtime-common/src/mock.rs
+++ b/bridges/bin/runtime-common/src/mock.rs
@@ -18,8 +18,6 @@
#![cfg(test)]
-use crate::messages_xcm_extension::XcmAsPlainPayload;
-
use bp_header_chain::ChainWithGrandpa;
use bp_messages::{
target_chain::{DispatchMessage, MessageDispatch},
@@ -28,6 +26,7 @@ use bp_messages::{
use bp_parachains::SingleParaStoredHeaderDataBuilder;
use bp_relayers::PayRewardFromAccount;
use bp_runtime::{messages::MessageDispatchResult, Chain, ChainId, Parachain};
+use codec::Encode;
use frame_support::{
derive_impl, parameter_types,
weights::{ConstantMultiplier, IdentityFee, RuntimeDbWeight, Weight},
@@ -85,7 +84,11 @@ pub type TestStakeAndSlash = pallet_bridge_relayers::StakeAndSlashNamed<
>;
/// Message lane used in tests.
-pub const TEST_LANE_ID: LaneId = LaneId([0, 0, 0, 0]);
+#[allow(unused)]
+pub fn test_lane_id() -> LaneId {
+ LaneId::new(1, 2)
+}
+
/// Bridged chain id used in tests.
pub const TEST_BRIDGED_CHAIN_ID: ChainId = *b"brdg";
/// Maximal extrinsic size at the `BridgedChain`.
@@ -111,7 +114,6 @@ crate::generate_bridge_reject_obsolete_headers_and_messages! {
}
parameter_types! {
- pub const ActiveOutboundLanes: &'static [LaneId] = &[TEST_LANE_ID];
pub const BridgedParasPalletName: &'static str = "Paras";
pub const ExistentialDeposit: ThisChainBalance = 500;
pub const DbWeight: RuntimeDbWeight = RuntimeDbWeight { read: 1, write: 2 };
@@ -185,9 +187,8 @@ impl pallet_bridge_parachains::Config for TestRuntime {
impl pallet_bridge_messages::Config for TestRuntime {
type RuntimeEvent = RuntimeEvent;
type WeightInfo = pallet_bridge_messages::weights::BridgeWeight;
- type ActiveOutboundLanes = ActiveOutboundLanes;
- type OutboundPayload = XcmAsPlainPayload;
+ type OutboundPayload = Vec;
type InboundPayload = Vec;
type DeliveryPayments = ();
@@ -218,8 +219,8 @@ impl pallet_bridge_relayers::Config for TestRuntime {
pub struct DummyMessageDispatch;
impl DummyMessageDispatch {
- pub fn deactivate() {
- frame_support::storage::unhashed::put(&b"inactive"[..], &false);
+ pub fn deactivate(lane: LaneId) {
+ frame_support::storage::unhashed::put(&(b"inactive", lane).encode()[..], &false);
}
}
@@ -227,8 +228,9 @@ impl MessageDispatch for DummyMessageDispatch {
type DispatchPayload = Vec;
type DispatchLevelResult = ();
- fn is_active() -> bool {
- frame_support::storage::unhashed::take::(&b"inactive"[..]) != Some(false)
+ fn is_active(lane: LaneId) -> bool {
+ frame_support::storage::unhashed::take::(&(b"inactive", lane).encode()[..]) !=
+ Some(false)
}
fn dispatch_weight(_message: &mut DispatchMessage) -> Weight {
diff --git a/bridges/bin/runtime-common/src/parachains_benchmarking.rs b/bridges/bin/runtime-common/src/parachains_benchmarking.rs
index bcbd779b44dea5fbef7781335cfa1d359ab8c1f1..e48a5664e31a62da3de91aaf368b6ad8ed2f0840 100644
--- a/bridges/bin/runtime-common/src/parachains_benchmarking.rs
+++ b/bridges/bin/runtime-common/src/parachains_benchmarking.rs
@@ -20,12 +20,13 @@
use crate::messages_benchmarking::insert_header_to_grandpa_pallet;
-use bp_parachains::parachain_head_storage_key_at_source;
+use bp_parachains::{
+ parachain_head_storage_key_at_source, RelayBlockHash, RelayBlockHasher, RelayBlockNumber,
+};
use bp_polkadot_core::parachains::{ParaHash, ParaHead, ParaHeadsProof, ParaId};
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};
use sp_std::prelude::*;
use sp_trie::{trie_types::TrieDBMutBuilderV1, LayoutV1, MemoryDB, TrieMut};
diff --git a/bridges/chains/chain-bridge-hub-rococo/Cargo.toml b/bridges/chains/chain-bridge-hub-rococo/Cargo.toml
index 66848ba0e2634b3b4e525f27013b04768204c749..23fbd9a2742f7ccf137bad53372e6e80d62a65c0 100644
--- a/bridges/chains/chain-bridge-hub-rococo/Cargo.toml
+++ b/bridges/chains/chain-bridge-hub-rococo/Cargo.toml
@@ -14,14 +14,15 @@ exclude-from-umbrella = true
workspace = true
[dependencies]
-# Bridge Dependencies
+codec = { features = ["derive"], workspace = true }
+# Bridge Dependencies
bp-bridge-hub-cumulus = { workspace = true }
bp-runtime = { workspace = true }
bp-messages = { workspace = true }
+bp-xcm-bridge-hub = { workspace = true }
# Substrate Based Dependencies
-
frame-support = { workspace = true }
sp-api = { workspace = true }
sp-runtime = { workspace = true }
@@ -33,6 +34,8 @@ std = [
"bp-bridge-hub-cumulus/std",
"bp-messages/std",
"bp-runtime/std",
+ "bp-xcm-bridge-hub/std",
+ "codec/std",
"frame-support/std",
"sp-api/std",
"sp-runtime/std",
diff --git a/bridges/chains/chain-bridge-hub-rococo/src/lib.rs b/bridges/chains/chain-bridge-hub-rococo/src/lib.rs
index 73af997b9950ef640040e44cbba0b93b6a7a56a3..7920eb93403376159c7520dcca31295116193d08 100644
--- a/bridges/chains/chain-bridge-hub-rococo/src/lib.rs
+++ b/bridges/chains/chain-bridge-hub-rococo/src/lib.rs
@@ -25,6 +25,7 @@ use bp_messages::*;
use bp_runtime::{
decl_bridge_finality_runtime_apis, decl_bridge_messages_runtime_apis, Chain, ChainId, Parachain,
};
+use codec::{Decode, Encode};
use frame_support::{
dispatch::DispatchClass,
sp_runtime::{MultiAddress, MultiSigner, RuntimeDebug, StateVersion},
@@ -104,13 +105,21 @@ frame_support::parameter_types! {
/// The XCM fee that is paid for executing XCM program (with `ExportMessage` instruction) at the Rococo
/// BridgeHub.
/// (initially was calculated by test `BridgeHubRococo::can_calculate_weight_for_paid_export_message_with_reserve_transfer` + `33%`)
- pub const BridgeHubRococoBaseXcmFeeInRocs: u128 = 59_034_266;
+ pub const BridgeHubRococoBaseXcmFeeInRocs: u128 = 57_145_832;
/// Transaction fee that is paid at the Rococo BridgeHub for delivering single inbound message.
/// (initially was calculated by test `BridgeHubRococo::can_calculate_fee_for_standalone_message_delivery_transaction` + `33%`)
- pub const BridgeHubRococoBaseDeliveryFeeInRocs: u128 = 314_037_860;
+ pub const BridgeHubRococoBaseDeliveryFeeInRocs: u128 = 297_644_174;
/// 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_standalone_message_confirmation_transaction` + `33%`)
- pub const BridgeHubRococoBaseConfirmationFeeInRocs: u128 = 57_414_813;
+ pub const BridgeHubRococoBaseConfirmationFeeInRocs: u128 = 56_740_432;
+}
+
+/// Wrapper over `BridgeHubRococo`'s `RuntimeCall` that can be used without a runtime.
+#[derive(Decode, Encode)]
+pub enum RuntimeCall {
+ /// Points to the `pallet_xcm_bridge_hub` pallet instance for `BridgeHubWestend`.
+ #[codec(index = 52)]
+ XcmOverBridgeHubWestend(bp_xcm_bridge_hub::XcmBridgeHubCall),
}
diff --git a/bridges/chains/chain-bridge-hub-westend/Cargo.toml b/bridges/chains/chain-bridge-hub-westend/Cargo.toml
index 24a196c1d70d128c49ddb788a699fe6e22e6c359..61357e6aa6c848c32614524cf8a755511bad81d3 100644
--- a/bridges/chains/chain-bridge-hub-westend/Cargo.toml
+++ b/bridges/chains/chain-bridge-hub-westend/Cargo.toml
@@ -14,15 +14,15 @@ exclude-from-umbrella = true
workspace = true
[dependencies]
+codec = { features = ["derive"], workspace = true }
# Bridge Dependencies
-
bp-bridge-hub-cumulus = { workspace = true }
bp-runtime = { workspace = true }
bp-messages = { workspace = true }
+bp-xcm-bridge-hub = { workspace = true }
# Substrate Based Dependencies
-
frame-support = { workspace = true }
sp-api = { workspace = true }
sp-runtime = { workspace = true }
@@ -34,6 +34,8 @@ std = [
"bp-bridge-hub-cumulus/std",
"bp-messages/std",
"bp-runtime/std",
+ "bp-xcm-bridge-hub/std",
+ "codec/std",
"frame-support/std",
"sp-api/std",
"sp-runtime/std",
diff --git a/bridges/chains/chain-bridge-hub-westend/src/lib.rs b/bridges/chains/chain-bridge-hub-westend/src/lib.rs
index 17ff2c858a1d3eeae329cb972d95adc32952ede4..644fa64c687b3162f1380cf3e666373226c0a16d 100644
--- a/bridges/chains/chain-bridge-hub-westend/src/lib.rs
+++ b/bridges/chains/chain-bridge-hub-westend/src/lib.rs
@@ -24,6 +24,7 @@ use bp_messages::*;
use bp_runtime::{
decl_bridge_finality_runtime_apis, decl_bridge_messages_runtime_apis, Chain, ChainId, Parachain,
};
+use codec::{Decode, Encode};
use frame_support::dispatch::DispatchClass;
use sp_runtime::{RuntimeDebug, StateVersion};
@@ -93,13 +94,21 @@ frame_support::parameter_types! {
/// The XCM fee that is paid for executing XCM program (with `ExportMessage` instruction) at the Westend
/// BridgeHub.
/// (initially was calculated by test `BridgeHubWestend::can_calculate_weight_for_paid_export_message_with_reserve_transfer` + `33%`)
- pub const BridgeHubWestendBaseXcmFeeInWnds: u128 = 17_756_830_000;
+ pub const BridgeHubWestendBaseXcmFeeInWnds: u128 = 18_191_740_000;
/// Transaction fee that is paid at the Westend BridgeHub for delivering single inbound message.
/// (initially was calculated by test `BridgeHubWestend::can_calculate_fee_for_standalone_message_delivery_transaction` + `33%`)
- pub const BridgeHubWestendBaseDeliveryFeeInWnds: u128 = 94_211_536_452;
+ pub const BridgeHubWestendBaseDeliveryFeeInWnds: u128 = 89_293_427_116;
/// Transaction fee that is paid at the Westend BridgeHub for delivering single outbound message confirmation.
/// (initially was calculated by test `BridgeHubWestend::can_calculate_fee_for_standalone_message_confirmation_transaction` + `33%`)
- pub const BridgeHubWestendBaseConfirmationFeeInWnds: u128 = 17_224_486_452;
+ pub const BridgeHubWestendBaseConfirmationFeeInWnds: u128 = 17_022_177_116;
+}
+
+/// Wrapper over `BridgeHubWestend`'s `RuntimeCall` that can be used without a runtime.
+#[derive(Decode, Encode)]
+pub enum RuntimeCall {
+ /// Points to the `pallet_xcm_bridge_hub` pallet instance for `BridgeHubRococo`.
+ #[codec(index = 45)]
+ XcmOverBridgeHubRococo(bp_xcm_bridge_hub::XcmBridgeHubCall),
}
diff --git a/bridges/docs/polkadot-kusama-bridge-overview.md b/bridges/docs/polkadot-kusama-bridge-overview.md
index 08036f0b0722b869786ae3d0abfc6ae7ea7c2c18..b1812e4caf126995566f7531d43cdf4f307a4c5f 100644
--- a/bridges/docs/polkadot-kusama-bridge-overview.md
+++ b/bridges/docs/polkadot-kusama-bridge-overview.md
@@ -25,8 +25,9 @@ You won't be able to directly use bridge hub transactions to send XCM messages o
use other parachains transactions, which will use HRMP to deliver messages to the Bridge Hub. The Bridge Hub will just
queue these messages in its outbound lane, which is dedicated to deliver messages between two parachains.
-Our first planned bridge will connect the Polkadot and Kusama Asset Hubs. A bridge between those two parachains would
-allow Asset Hub Polkadot accounts to hold wrapped KSM tokens and Asset Hub Kusama accounts to hold wrapped DOT tokens.
+Our first planned bridge will connect the Polkadot and Kusama Asset Hubs. A bridge between those two
+parachains would allow Asset Hub Polkadot accounts to hold wrapped KSM tokens and Asset Hub Kusama
+accounts to hold wrapped DOT tokens.
For that bridge (pair of parachains under different consensus systems) we'll be using the lane 00000000. Later, when
other parachains will join the bridge, they will be using other lanes for their messages.
@@ -92,13 +93,14 @@ Obviously, there should be someone who is paying relayer rewards. We want bridge
can't use fees for rewards. Instead, the parachains using the bridge, use sovereign accounts on both sides of the bridge
to cover relayer rewards.
-Bridged Parachains will have sovereign accounts at bridge hubs. For example, the Kusama Asset Hub will have an account
-at the Polkadot Bridge Hub. The Polkadot Asset Hub will have an account at the Kusama Bridge Hub. The sovereign accounts
-are used as a source of funds when the relayer is calling the `pallet_bridge_relayers::claim_rewards`.
+Bridged Parachains will have sovereign accounts at bridge hubs. For example, the Kusama Asset Hub will
+have an account at the Polkadot Bridge Hub. The Polkadot Asset Hub will have an account at the Kusama
+Bridge Hub. The sovereign accounts are used as a source of funds when the relayer is calling the
+`pallet_bridge_relayers::claim_rewards`.
-Since messages lane is only used by the pair of parachains, there's no collision between different bridges. E.g. Kusama
-Asset Hub will only reward relayers that are delivering messages from Kusama Asset Hub. The Kusama Asset Hub sovereign
-account is not used to cover rewards of bridging with some other Polkadot Parachain.
+Since messages lane is only used by the pair of parachains, there's no collision between different bridges. E.g.
+Kusama Asset Hub will only reward relayers that are delivering messages from Kusama Asset Hub.
+The Kusama Asset Hub sovereign account is not used to cover rewards of bridging with some other Polkadot Parachain.
### Multiple Relayers and Rewards
diff --git a/bridges/modules/grandpa/src/call_ext.rs b/bridges/modules/grandpa/src/call_ext.rs
index f08eb4c5d1ab5ae231afc388dacb0699d58fbc46..d964901ba4bc6681246b1b9d30104e652a282fa1 100644
--- a/bridges/modules/grandpa/src/call_ext.rs
+++ b/bridges/modules/grandpa/src/call_ext.rs
@@ -18,7 +18,10 @@ use crate::{
weights::WeightInfo, BestFinalized, BridgedBlockNumber, BridgedHeader, Config,
CurrentAuthoritySet, Error, FreeHeadersRemaining, Pallet,
};
-use bp_header_chain::{justification::GrandpaJustification, submit_finality_proof_limits_extras};
+use bp_header_chain::{
+ justification::GrandpaJustification, submit_finality_proof_limits_extras,
+ SubmitFinalityProofInfo,
+};
use bp_runtime::{BlockNumberOf, Chain, OwnedBridgeModule};
use frame_support::{
dispatch::CallableCallFor,
@@ -31,37 +34,11 @@ use sp_runtime::{
transaction_validity::{InvalidTransaction, TransactionValidityError},
RuntimeDebug, SaturatedConversion,
};
-
-/// Info about a `SubmitParachainHeads` call which tries to update a single parachain.
-#[derive(Copy, Clone, PartialEq, RuntimeDebug)]
-pub struct SubmitFinalityProofInfo {
- /// Number of the finality target.
- pub block_number: N,
- /// An identifier of the validators set that has signed the submitted justification.
- /// It might be `None` if deprecated version of the `submit_finality_proof` is used.
- pub current_set_id: Option,
- /// If `true`, then the call proves new **mandatory** header.
- pub is_mandatory: bool,
- /// If `true`, then the call must be free (assuming that everything else is valid) to
- /// be treated as valid.
- pub is_free_execution_expected: bool,
- /// Extra weight that we assume is 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 weight above that limit, is never refunded.
- pub extra_weight: Weight,
- /// 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,
-}
+use sp_std::fmt::Debug;
/// Verified `SubmitFinalityProofInfo`.
#[derive(Copy, Clone, PartialEq, RuntimeDebug)]
-pub struct VerifiedSubmitFinalityProofInfo {
+pub struct VerifiedSubmitFinalityProofInfo {
/// Base call information.
pub base: SubmitFinalityProofInfo,
/// A difference between bundled bridged header and best bridged header known to us
@@ -69,13 +46,6 @@ pub struct VerifiedSubmitFinalityProofInfo {
pub improved_by: N,
}
-impl SubmitFinalityProofInfo {
- /// Returns `true` if call size/weight is below our estimations for regular calls.
- pub fn fits_limits(&self) -> bool {
- self.extra_weight.is_zero() && self.extra_size.is_zero()
- }
-}
-
/// Helper struct that provides methods for working with the `SubmitFinalityProof` call.
pub struct SubmitFinalityProofHelper, I: 'static> {
_phantom_data: sp_std::marker::PhantomData<(T, I)>,
@@ -336,9 +306,9 @@ mod tests {
TestRuntime,
},
BestFinalized, Config, CurrentAuthoritySet, FreeHeadersRemaining, PalletOperatingMode,
- StoredAuthoritySet, SubmitFinalityProofInfo, WeightInfo,
+ StoredAuthoritySet, WeightInfo,
};
- use bp_header_chain::ChainWithGrandpa;
+ use bp_header_chain::{ChainWithGrandpa, SubmitFinalityProofInfo};
use bp_runtime::{BasicOperatingMode, HeaderId};
use bp_test_utils::{
make_default_justification, make_justification_for_header, JustificationGeneratorParams,
diff --git a/bridges/modules/grandpa/src/lib.rs b/bridges/modules/grandpa/src/lib.rs
index c62951b74656b052d4858dec2af1393e41553029..dff4b98fd91904260545e581562668ab5be40b4a 100644
--- a/bridges/modules/grandpa/src/lib.rs
+++ b/bridges/modules/grandpa/src/lib.rs
@@ -117,7 +117,7 @@ pub mod pallet {
///
/// However, if the bridged chain gets compromised, its validators may generate as many
/// "free" headers as they want. And they may fill the whole block (at this chain) for
- /// free. This constants limits number of calls that we may refund in a single block.
+ /// free. This constant limits number of calls that we may refund in a single block.
/// All calls above this limit are accepted, but are not refunded.
#[pallet::constant]
type MaxFreeHeadersPerBlock: Get;
diff --git a/bridges/modules/messages/Cargo.toml b/bridges/modules/messages/Cargo.toml
index 33f524030d264e4ed292f8f67273e838e15fc3a9..9df318587e3895ee8d040a586f4d70770fc64f0f 100644
--- a/bridges/modules/messages/Cargo.toml
+++ b/bridges/modules/messages/Cargo.toml
@@ -73,7 +73,4 @@ try-runtime = [
"pallet-bridge-grandpa/try-runtime",
"sp-runtime/try-runtime",
]
-test-helpers = [
- "bp-runtime/test-helpers",
- "sp-trie",
-]
+test-helpers = ["bp-runtime/test-helpers", "sp-trie"]
diff --git a/bridges/modules/messages/README.md b/bridges/modules/messages/README.md
index 80fd92eb0e5a7d975ba45619838007a12f5f5553..a78c8680249851b86fe09c42d66d36914ca8dd80 100644
--- a/bridges/modules/messages/README.md
+++ b/bridges/modules/messages/README.md
@@ -28,9 +28,10 @@ Single message lane may be seen as a transport channel for single application (o
time the module itself never dictates any lane or message rules. In the end, it is the runtime developer who defines
what message lane and message mean for this runtime.
-In our [Kusama<>Polkadot bridge](../../docs/polkadot-kusama-bridge-overview.md) we are using lane as a channel of
-communication between two parachains of different relay chains. For example, lane `[0, 0, 0, 0]` is used for Polkadot <>
-Kusama Asset Hub communications. Other lanes may be used to bridge other parachains.
+In our [Kusama<>Polkadot bridge](../../docs/polkadot-kusama-bridge-overview.md) we are using lane
+as a channel of communication between two parachains of different relay chains. For example, lane
+`[0, 0, 0, 0]` is used for Polkadot <> Kusama Asset Hub communications. Other lanes may be used to
+bridge other parachains.
## Message Workflow
@@ -142,10 +143,9 @@ 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.
+`pallet_bridge_messages::Config::MaximalOutboundPayloadSize` constant defines the maximal size
+of outbound message that may be sent. If the message size is above this limit, the message is
+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
diff --git a/bridges/modules/messages/src/benchmarking.rs b/bridges/modules/messages/src/benchmarking.rs
index d38aaf32dc94bd157de0d3e910b729a7970c1684..b3a4447fb0211737cc5410a11c87dca9e12d8d80 100644
--- a/bridges/modules/messages/src/benchmarking.rs
+++ b/bridges/modules/messages/src/benchmarking.rs
@@ -19,14 +19,14 @@
#![cfg(feature = "runtime-benchmarks")]
use crate::{
- inbound_lane::InboundLaneStorage, outbound_lane, weights_ext::EXPECTED_DEFAULT_MESSAGE_LENGTH,
- BridgedChainOf, Call, OutboundLanes, RuntimeInboundLaneStorage,
+ active_outbound_lane, weights_ext::EXPECTED_DEFAULT_MESSAGE_LENGTH, BridgedChainOf, Call,
+ InboundLanes, OutboundLanes,
};
use bp_messages::{
source_chain::FromBridgedChainMessagesDeliveryProof,
target_chain::FromBridgedChainMessagesProof, ChainWithMessages, DeliveredMessages,
- InboundLaneData, LaneId, MessageNonce, OutboundLaneData, UnrewardedRelayer,
+ InboundLaneData, LaneId, LaneState, MessageNonce, OutboundLaneData, UnrewardedRelayer,
UnrewardedRelayersState,
};
use bp_runtime::{AccountIdOf, HashOf, UnverifiedStorageProofParams};
@@ -74,10 +74,8 @@ pub struct MessageDeliveryProofParams {
/// Trait that must be implemented by runtime.
pub trait Config: crate::Config {
/// Lane id to use in benchmarks.
- ///
- /// By default, lane 00000000 is used.
fn bench_lane_id() -> LaneId {
- LaneId([0, 0, 0, 0])
+ LaneId::new(1, 2)
}
/// Return id of relayer account at the bridged chain.
@@ -113,22 +111,32 @@ pub trait Config: crate::Config {
}
fn send_regular_message, I: 'static>() {
- let mut outbound_lane = outbound_lane::(T::bench_lane_id());
+ OutboundLanes::::insert(
+ T::bench_lane_id(),
+ OutboundLaneData {
+ state: LaneState::Opened,
+ latest_generated_nonce: 1,
+ ..Default::default()
+ },
+ );
+
+ let mut outbound_lane = active_outbound_lane::(T::bench_lane_id()).unwrap();
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,
- });
+ InboundLanes::::insert(
+ T::bench_lane_id(),
+ InboundLaneData {
+ state: LaneState::Opened,
+ relayers: vec![UnrewardedRelayer {
+ relayer: T::bridged_relayer_id(),
+ messages: DeliveredMessages::new(nonce),
+ }]
+ .into(),
+ last_confirmed_nonce: 0,
+ },
+ );
}
struct ReceiveMessagesProofSetup, I: 'static> {
@@ -173,8 +181,8 @@ impl, I: 'static> ReceiveMessagesProofSetup {
fn check_last_nonce(&self) {
assert_eq!(
- crate::InboundLanes::::get(&T::bench_lane_id()).last_delivered_nonce(),
- self.last_nonce(),
+ crate::InboundLanes::::get(&T::bench_lane_id()).map(|d| d.last_delivered_nonce()),
+ Some(self.last_nonce()),
);
}
}
@@ -277,6 +285,7 @@ mod benchmarks {
lane: T::bench_lane_id(),
message_nonces: setup.nonces(),
outbound_lane_data: Some(OutboundLaneData {
+ state: LaneState::Opened,
oldest_unpruned_nonce: setup.last_nonce(),
latest_received_nonce: ReceiveMessagesProofSetup::::LATEST_RECEIVED_NONCE,
latest_generated_nonce: setup.last_nonce(),
@@ -356,6 +365,7 @@ mod benchmarks {
let proof = T::prepare_message_delivery_proof(MessageDeliveryProofParams {
lane: T::bench_lane_id(),
inbound_lane_data: InboundLaneData {
+ state: LaneState::Opened,
relayers: vec![UnrewardedRelayer {
relayer: relayer_id.clone(),
messages: DeliveredMessages::new(1),
@@ -374,7 +384,10 @@ mod benchmarks {
relayers_state,
);
- assert_eq!(OutboundLanes::::get(T::bench_lane_id()).latest_received_nonce, 1);
+ assert_eq!(
+ OutboundLanes::::get(T::bench_lane_id()).map(|s| s.latest_received_nonce),
+ Some(1)
+ );
assert!(T::is_relayer_rewarded(&relayer_id));
}
@@ -404,6 +417,7 @@ mod benchmarks {
let proof = T::prepare_message_delivery_proof(MessageDeliveryProofParams {
lane: T::bench_lane_id(),
inbound_lane_data: InboundLaneData {
+ state: LaneState::Opened,
relayers: vec![UnrewardedRelayer {
relayer: relayer_id.clone(),
messages: delivered_messages,
@@ -422,7 +436,10 @@ mod benchmarks {
relayers_state,
);
- assert_eq!(OutboundLanes::::get(T::bench_lane_id()).latest_received_nonce, 2);
+ assert_eq!(
+ OutboundLanes::::get(T::bench_lane_id()).map(|s| s.latest_received_nonce),
+ Some(2)
+ );
assert!(T::is_relayer_rewarded(&relayer_id));
}
@@ -451,6 +468,7 @@ mod benchmarks {
let proof = T::prepare_message_delivery_proof(MessageDeliveryProofParams {
lane: T::bench_lane_id(),
inbound_lane_data: InboundLaneData {
+ state: LaneState::Opened,
relayers: vec![
UnrewardedRelayer {
relayer: relayer1_id.clone(),
@@ -475,7 +493,10 @@ mod benchmarks {
relayers_state,
);
- assert_eq!(OutboundLanes::::get(T::bench_lane_id()).latest_received_nonce, 2);
+ assert_eq!(
+ OutboundLanes::::get(T::bench_lane_id()).map(|s| s.latest_received_nonce),
+ Some(2)
+ );
assert!(T::is_relayer_rewarded(&relayer1_id));
assert!(T::is_relayer_rewarded(&relayer2_id));
}
diff --git a/bridges/bin/runtime-common/src/messages_call_ext.rs b/bridges/modules/messages/src/call_ext.rs
similarity index 57%
rename from bridges/bin/runtime-common/src/messages_call_ext.rs
rename to bridges/modules/messages/src/call_ext.rs
index a9ee1969ae0ca462f36098f03b4454e1399af129..8e021c8e5e242a6b89873b6178bdee6279d3b626 100644
--- a/bridges/bin/runtime-common/src/messages_call_ext.rs
+++ b/bridges/modules/messages/src/call_ext.rs
@@ -16,121 +16,18 @@
//! Helpers for easier manipulation of call processing with signed extensions.
+use crate::{BridgedChainOf, Config, InboundLanes, OutboundLanes, Pallet, LOG_TARGET};
+
use bp_messages::{
- target_chain::MessageDispatch, ChainWithMessages, InboundLaneData, LaneId, MessageNonce,
+ target_chain::MessageDispatch, BaseMessagesProofInfo, ChainWithMessages, InboundLaneData,
+ LaneId, MessageNonce, MessagesCallInfo, ReceiveMessagesDeliveryProofInfo,
+ ReceiveMessagesProofInfo, UnrewardedRelayerOccupation,
};
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;
-
-/// Generic info about a messages delivery/confirmation proof.
-#[derive(PartialEq, RuntimeDebug)]
-pub struct BaseMessagesProofInfo {
- /// Message lane, used by the call.
- pub lane_id: LaneId,
- /// Nonces of messages, included in the call.
- ///
- /// For delivery transaction, it is nonces of bundled messages. For confirmation
- /// transaction, it is nonces that are to be confirmed during the call.
- pub bundled_range: RangeInclusive,
- /// Nonce of the best message, stored by this chain before the call is dispatched.
- ///
- /// For delivery transaction, it is the nonce of best delivered message before the call.
- /// For confirmation transaction, it is the nonce of best confirmed message before the call.
- pub best_stored_nonce: MessageNonce,
-}
-
-impl BaseMessagesProofInfo {
- /// Returns true if `bundled_range` continues the `0..=best_stored_nonce` range.
- fn appends_to_stored_nonce(&self) -> bool {
- Some(*self.bundled_range.start()) == self.best_stored_nonce.checked_add(1)
- }
-}
-
-/// Occupation state of the unrewarded relayers vector.
-#[derive(PartialEq, RuntimeDebug)]
-#[cfg_attr(test, derive(Default))]
-pub struct UnrewardedRelayerOccupation {
- /// The number of remaining unoccupied entries for new relayers.
- pub free_relayer_slots: MessageNonce,
- /// The number of messages that we are ready to accept.
- pub free_message_slots: MessageNonce,
-}
-
-/// Info about a `ReceiveMessagesProof` call which tries to update a single lane.
-#[derive(PartialEq, RuntimeDebug)]
-pub struct ReceiveMessagesProofInfo {
- /// Base messages proof info
- pub base: BaseMessagesProofInfo,
- /// State of unrewarded relayers vector.
- pub unrewarded_relayers: UnrewardedRelayerOccupation,
-}
-
-impl ReceiveMessagesProofInfo {
- /// Returns true if:
- ///
- /// - either inbound lane is ready to accept bundled messages;
- ///
- /// - or there are no bundled messages, but the inbound lane is blocked by too many unconfirmed
- /// messages and/or unrewarded relayers.
- fn is_obsolete(&self, is_dispatcher_active: bool) -> bool {
- // if dispatcher is inactive, we don't accept any delivery transactions
- if !is_dispatcher_active {
- return true
- }
-
- // transactions with zero bundled nonces are not allowed, unless they're message
- // delivery transactions, which brings reward confirmations required to unblock
- // the lane
- if self.base.bundled_range.is_empty() {
- let empty_transactions_allowed =
- // we allow empty transactions when we can't accept delivery from new relayers
- self.unrewarded_relayers.free_relayer_slots == 0 ||
- // or if we can't accept new messages at all
- self.unrewarded_relayers.free_message_slots == 0;
-
- return !empty_transactions_allowed
- }
-
- // otherwise we require bundled messages to continue stored range
- !self.base.appends_to_stored_nonce()
- }
-}
-
-/// Info about a `ReceiveMessagesDeliveryProof` call which tries to update a single lane.
-#[derive(PartialEq, RuntimeDebug)]
-pub struct ReceiveMessagesDeliveryProofInfo(pub BaseMessagesProofInfo);
-
-impl ReceiveMessagesDeliveryProofInfo {
- /// Returns true if outbound lane is ready to accept confirmations of bundled messages.
- fn is_obsolete(&self) -> bool {
- self.0.bundled_range.is_empty() || !self.0.appends_to_stored_nonce()
- }
-}
-
-/// Info about a `ReceiveMessagesProof` or a `ReceiveMessagesDeliveryProof` call
-/// which tries to update a single lane.
-#[derive(PartialEq, RuntimeDebug)]
-pub enum CallInfo {
- /// Messages delivery call info.
- ReceiveMessagesProof(ReceiveMessagesProofInfo),
- /// Messages delivery confirmation call info.
- ReceiveMessagesDeliveryProof(ReceiveMessagesDeliveryProofInfo),
-}
-
-impl CallInfo {
- /// Returns range of messages, bundled with the call.
- pub fn bundled_messages(&self) -> RangeInclusive {
- match *self {
- Self::ReceiveMessagesProof(ref info) => info.base.bundled_range.clone(),
- Self::ReceiveMessagesDeliveryProof(ref info) => info.0.bundled_range.clone(),
- }
- }
-}
+use sp_runtime::transaction_validity::TransactionValidity;
-/// Helper struct that provides methods for working with a call supported by `CallInfo`.
+/// Helper struct that provides methods for working with a call supported by `MessagesCallInfo`.
pub struct CallHelper, I: 'static> {
_phantom_data: sp_std::marker::PhantomData<(T, I)>,
}
@@ -142,11 +39,13 @@ impl, I: 'static> CallHelper {
///
/// - call is `receive_messages_delivery_proof` and all messages confirmations have been
/// received.
- pub fn was_successful(info: &CallInfo) -> bool {
+ pub fn was_successful(info: &MessagesCallInfo) -> bool {
match info {
- CallInfo::ReceiveMessagesProof(info) => {
- let inbound_lane_data =
- pallet_bridge_messages::InboundLanes::::get(info.base.lane_id);
+ MessagesCallInfo::ReceiveMessagesProof(info) => {
+ let inbound_lane_data = match InboundLanes::::get(info.base.lane_id) {
+ Some(inbound_lane_data) => inbound_lane_data,
+ None => return false,
+ };
if info.base.bundled_range.is_empty() {
let post_occupation =
unrewarded_relayers_occupation::(&inbound_lane_data);
@@ -160,9 +59,11 @@ impl, I: 'static> CallHelper {
inbound_lane_data.last_delivered_nonce() == *info.base.bundled_range.end()
},
- CallInfo::ReceiveMessagesDeliveryProof(info) => {
- let outbound_lane_data =
- pallet_bridge_messages::OutboundLanes::::get(info.0.lane_id);
+ MessagesCallInfo::ReceiveMessagesDeliveryProof(info) => {
+ let outbound_lane_data = match OutboundLanes::::get(info.0.lane_id) {
+ Some(outbound_lane_data) => outbound_lane_data,
+ None => return false,
+ };
outbound_lane_data.latest_received_nonce == *info.0.bundled_range.end()
},
}
@@ -170,7 +71,7 @@ impl, I: 'static> CallHelper {
}
/// Trait representing a call that is a sub type of `pallet_bridge_messages::Call`.
-pub trait MessagesCallSubType, I: 'static>:
+pub trait CallSubType, I: 'static>:
IsSubType, T>>
{
/// Create a new instance of `ReceiveMessagesProofInfo` from a `ReceiveMessagesProof` call.
@@ -180,13 +81,13 @@ pub trait MessagesCallSubType, I: 'static>:
/// a `ReceiveMessagesDeliveryProof` call.
fn receive_messages_delivery_proof_info(&self) -> Option;
- /// Create a new instance of `CallInfo` from a `ReceiveMessagesProof`
+ /// Create a new instance of `MessagesCallInfo` from a `ReceiveMessagesProof`
/// or a `ReceiveMessagesDeliveryProof` call.
- fn call_info(&self) -> Option;
+ fn call_info(&self) -> Option;
- /// Create a new instance of `CallInfo` from a `ReceiveMessagesProof`
+ /// Create a new instance of `MessagesCallInfo` from a `ReceiveMessagesProof`
/// or a `ReceiveMessagesDeliveryProof` call, if the call is for the provided lane.
- fn call_info_for(&self, lane_id: LaneId) -> Option;
+ fn call_info_for(&self, lane_id: LaneId) -> Option;
/// Ensures that a `ReceiveMessagesProof` or a `ReceiveMessagesDeliveryProof` call:
///
@@ -211,15 +112,13 @@ impl<
Call: IsSubType, T>>,
T: frame_system::Config + Config,
I: 'static,
- > MessagesCallSubType for T::RuntimeCall
+ > CallSubType for T::RuntimeCall
{
fn receive_messages_proof_info(&self) -> Option {
- if let Some(pallet_bridge_messages::Call::::receive_messages_proof {
- ref proof,
- ..
- }) = self.is_sub_type()
+ if let Some(crate::Call::::receive_messages_proof { ref proof, .. }) =
+ self.is_sub_type()
{
- let inbound_lane_data = pallet_bridge_messages::InboundLanes::::get(proof.lane);
+ let inbound_lane_data = InboundLanes::::get(proof.lane)?;
return Some(ReceiveMessagesProofInfo {
base: BaseMessagesProofInfo {
@@ -237,13 +136,13 @@ impl<
}
fn receive_messages_delivery_proof_info(&self) -> Option {
- if let Some(pallet_bridge_messages::Call::::receive_messages_delivery_proof {
+ if let Some(crate::Call::::receive_messages_delivery_proof {
ref proof,
ref relayers_state,
..
}) = self.is_sub_type()
{
- let outbound_lane_data = pallet_bridge_messages::OutboundLanes::::get(proof.lane);
+ let outbound_lane_data = OutboundLanes::::get(proof.lane)?;
return Some(ReceiveMessagesDeliveryProofInfo(BaseMessagesProofInfo {
lane_id: proof.lane,
@@ -260,23 +159,23 @@ impl<
None
}
- fn call_info(&self) -> Option {
+ fn call_info(&self) -> Option {
if let Some(info) = self.receive_messages_proof_info() {
- return Some(CallInfo::ReceiveMessagesProof(info))
+ return Some(MessagesCallInfo::ReceiveMessagesProof(info))
}
if let Some(info) = self.receive_messages_delivery_proof_info() {
- return Some(CallInfo::ReceiveMessagesDeliveryProof(info))
+ return Some(MessagesCallInfo::ReceiveMessagesDeliveryProof(info))
}
None
}
- fn call_info_for(&self, lane_id: LaneId) -> Option {
+ fn call_info_for(&self, lane_id: LaneId) -> Option {
self.call_info().filter(|info| {
let actual_lane_id = match info {
- CallInfo::ReceiveMessagesProof(info) => info.base.lane_id,
- CallInfo::ReceiveMessagesDeliveryProof(info) => info.0.lane_id,
+ MessagesCallInfo::ReceiveMessagesProof(info) => info.base.lane_id,
+ MessagesCallInfo::ReceiveMessagesDeliveryProof(info) => info.0.lane_id,
};
actual_lane_id == lane_id
})
@@ -287,29 +186,30 @@ impl<
match self.call_info() {
Some(proof_info) if is_pallet_halted => {
log::trace!(
- target: pallet_bridge_messages::LOG_TARGET,
+ target: LOG_TARGET,
"Rejecting messages transaction on halted pallet: {:?}",
proof_info
);
return sp_runtime::transaction_validity::InvalidTransaction::Call.into()
},
- Some(CallInfo::ReceiveMessagesProof(proof_info))
- if proof_info.is_obsolete(T::MessageDispatch::is_active()) =>
+ Some(MessagesCallInfo::ReceiveMessagesProof(proof_info))
+ if proof_info
+ .is_obsolete(T::MessageDispatch::is_active(proof_info.base.lane_id)) =>
{
log::trace!(
- target: pallet_bridge_messages::LOG_TARGET,
+ target: LOG_TARGET,
"Rejecting obsolete messages delivery transaction: {:?}",
proof_info
);
return sp_runtime::transaction_validity::InvalidTransaction::Stale.into()
},
- Some(CallInfo::ReceiveMessagesDeliveryProof(proof_info))
+ Some(MessagesCallInfo::ReceiveMessagesDeliveryProof(proof_info))
if proof_info.is_obsolete() =>
{
log::trace!(
- target: pallet_bridge_messages::LOG_TARGET,
+ target: LOG_TARGET,
"Rejecting obsolete messages confirmation transaction: {:?}",
proof_info,
);
@@ -343,52 +243,49 @@ fn unrewarded_relayers_occupation, I: 'static>(
#[cfg(test)]
mod tests {
use super::*;
- use crate::{
- messages_call_ext::MessagesCallSubType,
- mock::{BridgedUnderlyingChain, DummyMessageDispatch, TestRuntime, ThisChainRuntimeCall},
- };
+ use crate::tests::mock::*;
use bp_messages::{
source_chain::FromBridgedChainMessagesDeliveryProof,
- target_chain::FromBridgedChainMessagesProof, DeliveredMessages, UnrewardedRelayer,
- UnrewardedRelayersState,
+ target_chain::FromBridgedChainMessagesProof, DeliveredMessages, InboundLaneData, LaneState,
+ OutboundLaneData, UnrewardedRelayer, UnrewardedRelayersState,
};
use sp_std::ops::RangeInclusive;
+ fn test_lane_id() -> LaneId {
+ LaneId::new(1, 2)
+ }
+
fn fill_unrewarded_relayers() {
- let mut inbound_lane_state =
- pallet_bridge_messages::InboundLanes::::get(LaneId([0, 0, 0, 0]));
- for n in 0..BridgedUnderlyingChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX {
+ let mut inbound_lane_state = InboundLanes::::get(test_lane_id()).unwrap();
+ for n in 0..BridgedChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX {
inbound_lane_state.relayers.push_back(UnrewardedRelayer {
relayer: Default::default(),
messages: DeliveredMessages { begin: n + 1, end: n + 1 },
});
}
- pallet_bridge_messages::InboundLanes::::insert(
- LaneId([0, 0, 0, 0]),
- inbound_lane_state,
- );
+ InboundLanes::::insert(test_lane_id(), inbound_lane_state);
}
fn fill_unrewarded_messages() {
- let mut inbound_lane_state =
- pallet_bridge_messages::InboundLanes::::get(LaneId([0, 0, 0, 0]));
+ let mut inbound_lane_state = InboundLanes::::get(test_lane_id()).unwrap();
inbound_lane_state.relayers.push_back(UnrewardedRelayer {
relayer: Default::default(),
messages: DeliveredMessages {
begin: 1,
- end: BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
+ end: BridgedChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
},
});
- pallet_bridge_messages::InboundLanes::::insert(
- LaneId([0, 0, 0, 0]),
- inbound_lane_state,
- );
+ InboundLanes::::insert(test_lane_id(), inbound_lane_state);
}
fn deliver_message_10() {
- pallet_bridge_messages::InboundLanes::::insert(
- LaneId([0, 0, 0, 0]),
- bp_messages::InboundLaneData { relayers: Default::default(), last_confirmed_nonce: 10 },
+ InboundLanes::::insert(
+ test_lane_id(),
+ bp_messages::InboundLaneData {
+ state: LaneState::Opened,
+ relayers: Default::default(),
+ last_confirmed_nonce: 10,
+ },
);
}
@@ -396,28 +293,33 @@ mod tests {
nonces_start: bp_messages::MessageNonce,
nonces_end: bp_messages::MessageNonce,
) -> bool {
- ThisChainRuntimeCall::BridgeMessages(
- pallet_bridge_messages::Call::::receive_messages_proof {
- relayer_id_at_bridged_chain: 42,
- 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: Box::new(FromBridgedChainMessagesProof {
- bridged_header_hash: Default::default(),
- storage_proof: Default::default(),
- lane: LaneId([0, 0, 0, 0]),
- nonces_start,
- nonces_end,
- }),
- },
- )
+ RuntimeCall::Messages(crate::Call::::receive_messages_proof {
+ relayer_id_at_bridged_chain: 42,
+ 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: Box::new(FromBridgedChainMessagesProof {
+ bridged_header_hash: Default::default(),
+ storage_proof: Default::default(),
+ lane: test_lane_id(),
+ nonces_start,
+ nonces_end,
+ }),
+ })
.check_obsolete_call()
.is_ok()
}
+ fn run_test(test: impl Fn() -> T) -> T {
+ sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ InboundLanes::::insert(test_lane_id(), InboundLaneData::opened());
+ OutboundLanes::::insert(test_lane_id(), OutboundLaneData::opened());
+ test()
+ })
+ }
+
#[test]
fn extension_rejects_obsolete_messages() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
// when current best delivered is message#10 and we're trying to deliver messages 8..=9
// => tx is rejected
deliver_message_10();
@@ -427,7 +329,7 @@ mod tests {
#[test]
fn extension_rejects_same_message() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
// when current best delivered is message#10 and we're trying to import messages 10..=10
// => tx is rejected
deliver_message_10();
@@ -437,7 +339,7 @@ mod tests {
#[test]
fn extension_rejects_call_with_some_obsolete_messages() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
// when current best delivered is message#10 and we're trying to deliver messages
// 10..=15 => tx is rejected
deliver_message_10();
@@ -447,7 +349,7 @@ mod tests {
#[test]
fn extension_rejects_call_with_future_messages() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
// when current best delivered is message#10 and we're trying to deliver messages
// 13..=15 => tx is rejected
deliver_message_10();
@@ -457,12 +359,12 @@ mod tests {
#[test]
fn extension_reject_call_when_dispatcher_is_inactive() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
// when current best delivered is message#10 and we're trying to deliver message 11..=15
// => tx is accepted, but we have inactive dispatcher, so...
deliver_message_10();
- DummyMessageDispatch::deactivate();
+ TestMessageDispatch::deactivate(test_lane_id());
assert!(!validate_message_delivery(11, 15));
});
}
@@ -470,7 +372,7 @@ mod tests {
#[test]
fn extension_rejects_empty_delivery_with_rewards_confirmations_if_there_are_free_relayer_and_message_slots(
) {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
deliver_message_10();
assert!(!validate_message_delivery(10, 9));
});
@@ -479,7 +381,7 @@ mod tests {
#[test]
fn extension_accepts_empty_delivery_with_rewards_confirmations_if_there_are_no_free_relayer_slots(
) {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
deliver_message_10();
fill_unrewarded_relayers();
assert!(validate_message_delivery(10, 9));
@@ -489,18 +391,18 @@ mod tests {
#[test]
fn extension_accepts_empty_delivery_with_rewards_confirmations_if_there_are_no_free_message_slots(
) {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
fill_unrewarded_messages();
assert!(validate_message_delivery(
- BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
- BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX - 1
+ BridgedChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
+ BridgedChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX - 1
));
});
}
#[test]
fn extension_accepts_new_messages() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
// when current best delivered is message#10 and we're trying to deliver message 11..=15
// => tx is accepted
deliver_message_10();
@@ -509,9 +411,10 @@ mod tests {
}
fn confirm_message_10() {
- pallet_bridge_messages::OutboundLanes::::insert(
- LaneId([0, 0, 0, 0]),
+ OutboundLanes::::insert(
+ test_lane_id(),
bp_messages::OutboundLaneData {
+ state: LaneState::Opened,
oldest_unpruned_nonce: 0,
latest_received_nonce: 10,
latest_generated_nonce: 10,
@@ -520,26 +423,21 @@ mod tests {
}
fn validate_message_confirmation(last_delivered_nonce: bp_messages::MessageNonce) -> bool {
- ThisChainRuntimeCall::BridgeMessages(
- pallet_bridge_messages::Call::::receive_messages_delivery_proof {
- proof: FromBridgedChainMessagesDeliveryProof {
- bridged_header_hash: Default::default(),
- storage_proof: Default::default(),
- lane: LaneId([0, 0, 0, 0]),
- },
- relayers_state: UnrewardedRelayersState {
- last_delivered_nonce,
- ..Default::default()
- },
+ RuntimeCall::Messages(crate::Call::::receive_messages_delivery_proof {
+ proof: FromBridgedChainMessagesDeliveryProof {
+ bridged_header_hash: Default::default(),
+ storage_proof: Default::default(),
+ lane: test_lane_id(),
},
- )
+ relayers_state: UnrewardedRelayersState { last_delivered_nonce, ..Default::default() },
+ })
.check_obsolete_call()
.is_ok()
}
#[test]
fn extension_rejects_obsolete_confirmations() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
// when current best confirmed is message#10 and we're trying to confirm message#5 => tx
// is rejected
confirm_message_10();
@@ -549,7 +447,7 @@ mod tests {
#[test]
fn extension_rejects_same_confirmation() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
// when current best confirmed is message#10 and we're trying to confirm message#10 =>
// tx is rejected
confirm_message_10();
@@ -559,7 +457,7 @@ mod tests {
#[test]
fn extension_rejects_empty_confirmation_even_if_there_are_no_free_unrewarded_entries() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
confirm_message_10();
fill_unrewarded_relayers();
assert!(!validate_message_confirmation(10));
@@ -568,7 +466,7 @@ mod tests {
#[test]
fn extension_accepts_new_confirmation() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
// when current best confirmed is message#10 and we're trying to confirm message#15 =>
// tx is accepted
confirm_message_10();
@@ -580,10 +478,10 @@ mod tests {
bundled_range: RangeInclusive,
is_empty: bool,
) -> bool {
- CallHelper::::was_successful(&CallInfo::ReceiveMessagesProof(
+ CallHelper::::was_successful(&MessagesCallInfo::ReceiveMessagesProof(
ReceiveMessagesProofInfo {
base: BaseMessagesProofInfo {
- lane_id: LaneId([0, 0, 0, 0]),
+ lane_id: test_lane_id(),
bundled_range,
best_stored_nonce: 0, // doesn't matter for `was_successful`
},
@@ -592,7 +490,7 @@ mod tests {
free_message_slots: if is_empty {
0
} else {
- BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX
+ BridgedChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX
},
},
},
@@ -602,7 +500,7 @@ mod tests {
#[test]
#[allow(clippy::reversed_empty_ranges)]
fn was_successful_returns_false_for_failed_reward_confirmation_transaction() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
fill_unrewarded_messages();
assert!(!was_message_delivery_successful(10..=9, true));
});
@@ -611,14 +509,14 @@ mod tests {
#[test]
#[allow(clippy::reversed_empty_ranges)]
fn was_successful_returns_true_for_successful_reward_confirmation_transaction() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
assert!(was_message_delivery_successful(10..=9, true));
});
}
#[test]
fn was_successful_returns_false_for_failed_delivery() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
deliver_message_10();
assert!(!was_message_delivery_successful(10..=12, false));
});
@@ -626,7 +524,7 @@ mod tests {
#[test]
fn was_successful_returns_false_for_partially_successful_delivery() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
deliver_message_10();
assert!(!was_message_delivery_successful(9..=12, false));
});
@@ -634,25 +532,27 @@ mod tests {
#[test]
fn was_successful_returns_true_for_successful_delivery() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
deliver_message_10();
assert!(was_message_delivery_successful(9..=10, false));
});
}
fn was_message_confirmation_successful(bundled_range: RangeInclusive) -> bool {
- CallHelper::::was_successful(&CallInfo::ReceiveMessagesDeliveryProof(
- ReceiveMessagesDeliveryProofInfo(BaseMessagesProofInfo {
- lane_id: LaneId([0, 0, 0, 0]),
- bundled_range,
- best_stored_nonce: 0, // doesn't matter for `was_successful`
- }),
- ))
+ CallHelper::::was_successful(
+ &MessagesCallInfo::ReceiveMessagesDeliveryProof(ReceiveMessagesDeliveryProofInfo(
+ BaseMessagesProofInfo {
+ lane_id: test_lane_id(),
+ bundled_range,
+ best_stored_nonce: 0, // doesn't matter for `was_successful`
+ },
+ )),
+ )
}
#[test]
fn was_successful_returns_false_for_failed_confirmation() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
confirm_message_10();
assert!(!was_message_confirmation_successful(10..=12));
});
@@ -660,7 +560,7 @@ mod tests {
#[test]
fn was_successful_returns_false_for_partially_successful_confirmation() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
confirm_message_10();
assert!(!was_message_confirmation_successful(9..=12));
});
@@ -668,7 +568,7 @@ mod tests {
#[test]
fn was_successful_returns_true_for_successful_confirmation() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ run_test(|| {
confirm_message_10();
assert!(was_message_confirmation_successful(9..=10));
});
diff --git a/bridges/modules/messages/src/inbound_lane.rs b/bridges/modules/messages/src/inbound_lane.rs
index 7ef4599a93c4823a9be7fa918b35c309cea6611a..65240feb7194aaef83ed5e2268f3fa44a4f739a6 100644
--- a/bridges/modules/messages/src/inbound_lane.rs
+++ b/bridges/modules/messages/src/inbound_lane.rs
@@ -20,8 +20,8 @@ use crate::{BridgedChainOf, Config};
use bp_messages::{
target_chain::{DispatchMessage, DispatchMessageData, MessageDispatch},
- ChainWithMessages, DeliveredMessages, InboundLaneData, LaneId, MessageKey, MessageNonce,
- OutboundLaneData, ReceptionResult, UnrewardedRelayer,
+ ChainWithMessages, DeliveredMessages, InboundLaneData, LaneId, LaneState, MessageKey,
+ MessageNonce, OutboundLaneData, ReceptionResult, UnrewardedRelayer,
};
use bp_runtime::AccountIdOf;
use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};
@@ -41,9 +41,11 @@ pub trait InboundLaneStorage {
/// Return maximal number of unconfirmed messages in inbound lane.
fn max_unconfirmed_messages(&self) -> MessageNonce;
/// Get lane data from the storage.
- fn get_or_init_data(&mut self) -> InboundLaneData;
+ fn data(&self) -> InboundLaneData;
/// Update lane data in the storage.
fn set_data(&mut self, data: InboundLaneData);
+ /// Purge lane data from the storage.
+ fn purge(self);
}
/// Inbound lane data wrapper that implements `MaxEncodedLen`.
@@ -120,9 +122,21 @@ impl InboundLane {
InboundLane { storage }
}
- /// Returns `mut` storage reference.
- pub fn storage_mut(&mut self) -> &mut S {
- &mut self.storage
+ /// Get lane state.
+ pub fn state(&self) -> LaneState {
+ self.storage.data().state
+ }
+
+ /// Returns storage reference.
+ pub fn storage(&self) -> &S {
+ &self.storage
+ }
+
+ /// Set lane state.
+ pub fn set_state(&mut self, state: LaneState) {
+ let mut data = self.storage.data();
+ data.state = state;
+ self.storage.set_data(data);
}
/// Receive state of the corresponding outbound lane.
@@ -130,7 +144,7 @@ impl InboundLane {
&mut self,
outbound_lane_data: OutboundLaneData,
) -> Option {
- let mut data = self.storage.get_or_init_data();
+ let mut data = self.storage.data();
let last_delivered_nonce = data.last_delivered_nonce();
if outbound_lane_data.latest_received_nonce > last_delivered_nonce {
@@ -173,7 +187,7 @@ impl InboundLane {
nonce: MessageNonce,
message_data: DispatchMessageData,
) -> ReceptionResult {
- let mut data = self.storage.get_or_init_data();
+ let mut data = self.storage.data();
if Some(nonce) != data.last_delivered_nonce().checked_add(1) {
return ReceptionResult::InvalidNonce
}
@@ -211,20 +225,17 @@ impl InboundLane {
ReceptionResult::Dispatched(dispatch_result)
}
+
+ /// Purge lane state from the storage.
+ pub fn purge(self) {
+ self.storage.purge()
+ }
}
#[cfg(test)]
mod tests {
use super::*;
- use crate::{
- inbound_lane,
- tests::mock::{
- dispatch_result, inbound_message_data, inbound_unrewarded_relayers_state, run_test,
- unrewarded_relayer, BridgedChain, TestMessageDispatch, TestRuntime, REGULAR_PAYLOAD,
- TEST_LANE_ID, TEST_RELAYER_A, TEST_RELAYER_B, TEST_RELAYER_C,
- },
- RuntimeInboundLaneStorage,
- };
+ use crate::{active_inbound_lane, lanes_manager::RuntimeInboundLaneStorage, tests::mock::*};
use bp_messages::UnrewardedRelayersState;
fn receive_regular_message(
@@ -244,7 +255,7 @@ mod tests {
#[test]
fn receive_status_update_ignores_status_from_the_future() {
run_test(|| {
- let mut lane = inbound_lane::(TEST_LANE_ID);
+ let mut lane = active_inbound_lane::(test_lane_id()).unwrap();
receive_regular_message(&mut lane, 1);
assert_eq!(
lane.receive_state_update(OutboundLaneData {
@@ -254,14 +265,14 @@ mod tests {
None,
);
- assert_eq!(lane.storage.get_or_init_data().last_confirmed_nonce, 0);
+ assert_eq!(lane.storage.data().last_confirmed_nonce, 0);
});
}
#[test]
fn receive_status_update_ignores_obsolete_status() {
run_test(|| {
- let mut lane = inbound_lane::(TEST_LANE_ID);
+ let mut lane = active_inbound_lane::(test_lane_id()).unwrap();
receive_regular_message(&mut lane, 1);
receive_regular_message(&mut lane, 2);
receive_regular_message(&mut lane, 3);
@@ -272,7 +283,7 @@ mod tests {
}),
Some(3),
);
- assert_eq!(lane.storage.get_or_init_data().last_confirmed_nonce, 3);
+ assert_eq!(lane.storage.data().last_confirmed_nonce, 3);
assert_eq!(
lane.receive_state_update(OutboundLaneData {
@@ -281,20 +292,20 @@ mod tests {
}),
None,
);
- assert_eq!(lane.storage.get_or_init_data().last_confirmed_nonce, 3);
+ assert_eq!(lane.storage.data().last_confirmed_nonce, 3);
});
}
#[test]
fn receive_status_update_works() {
run_test(|| {
- let mut lane = inbound_lane::(TEST_LANE_ID);
+ let mut lane = active_inbound_lane::(test_lane_id()).unwrap();
receive_regular_message(&mut lane, 1);
receive_regular_message(&mut lane, 2);
receive_regular_message(&mut lane, 3);
- assert_eq!(lane.storage.get_or_init_data().last_confirmed_nonce, 0);
+ assert_eq!(lane.storage.data().last_confirmed_nonce, 0);
assert_eq!(
- lane.storage.get_or_init_data().relayers,
+ lane.storage.data().relayers,
vec![unrewarded_relayer(1, 3, TEST_RELAYER_A)]
);
@@ -305,9 +316,9 @@ mod tests {
}),
Some(2),
);
- assert_eq!(lane.storage.get_or_init_data().last_confirmed_nonce, 2);
+ assert_eq!(lane.storage.data().last_confirmed_nonce, 2);
assert_eq!(
- lane.storage.get_or_init_data().relayers,
+ lane.storage.data().relayers,
vec![unrewarded_relayer(3, 3, TEST_RELAYER_A)]
);
@@ -318,16 +329,16 @@ mod tests {
}),
Some(3),
);
- assert_eq!(lane.storage.get_or_init_data().last_confirmed_nonce, 3);
- assert_eq!(lane.storage.get_or_init_data().relayers, vec![]);
+ assert_eq!(lane.storage.data().last_confirmed_nonce, 3);
+ assert_eq!(lane.storage.data().relayers, vec![]);
});
}
#[test]
fn receive_status_update_works_with_batches_from_relayers() {
run_test(|| {
- let mut lane = inbound_lane::(TEST_LANE_ID);
- let mut seed_storage_data = lane.storage.get_or_init_data();
+ let mut lane = active_inbound_lane::(test_lane_id()).unwrap();
+ let mut seed_storage_data = lane.storage.data();
// Prepare data
seed_storage_data.last_confirmed_nonce = 0;
seed_storage_data.relayers.push_back(unrewarded_relayer(1, 1, TEST_RELAYER_A));
@@ -343,9 +354,9 @@ mod tests {
}),
Some(3),
);
- assert_eq!(lane.storage.get_or_init_data().last_confirmed_nonce, 3);
+ assert_eq!(lane.storage.data().last_confirmed_nonce, 3);
assert_eq!(
- lane.storage.get_or_init_data().relayers,
+ lane.storage.data().relayers,
vec![
unrewarded_relayer(4, 4, TEST_RELAYER_B),
unrewarded_relayer(5, 5, TEST_RELAYER_C)
@@ -357,7 +368,7 @@ mod tests {
#[test]
fn fails_to_receive_message_with_incorrect_nonce() {
run_test(|| {
- let mut lane = inbound_lane::(TEST_LANE_ID);
+ let mut lane = active_inbound_lane::(test_lane_id()).unwrap();
assert_eq!(
lane.receive_message::(
&TEST_RELAYER_A,
@@ -366,14 +377,14 @@ mod tests {
),
ReceptionResult::InvalidNonce
);
- assert_eq!(lane.storage.get_or_init_data().last_delivered_nonce(), 0);
+ assert_eq!(lane.storage.data().last_delivered_nonce(), 0);
});
}
#[test]
fn fails_to_receive_messages_above_unrewarded_relayer_entries_limit_per_lane() {
run_test(|| {
- let mut lane = inbound_lane::(TEST_LANE_ID);
+ let mut lane = active_inbound_lane::(test_lane_id()).unwrap();
let max_nonce = BridgedChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX;
for current_nonce in 1..max_nonce + 1 {
assert_eq!(
@@ -409,7 +420,7 @@ mod tests {
#[test]
fn fails_to_receive_messages_above_unconfirmed_messages_limit_per_lane() {
run_test(|| {
- let mut lane = inbound_lane::(TEST_LANE_ID);
+ let mut lane = active_inbound_lane::(test_lane_id()).unwrap();
let max_nonce = BridgedChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX;
for current_nonce in 1..=max_nonce {
assert_eq!(
@@ -445,7 +456,7 @@ mod tests {
#[test]
fn correctly_receives_following_messages_from_two_relayers_alternately() {
run_test(|| {
- let mut lane = inbound_lane::(TEST_LANE_ID);
+ let mut lane = active_inbound_lane::(test_lane_id()).unwrap();
assert_eq!(
lane.receive_message::(
&TEST_RELAYER_A,
@@ -471,7 +482,7 @@ mod tests {
ReceptionResult::Dispatched(dispatch_result(0))
);
assert_eq!(
- lane.storage.get_or_init_data().relayers,
+ lane.storage.data().relayers,
vec![
unrewarded_relayer(1, 1, TEST_RELAYER_A),
unrewarded_relayer(2, 2, TEST_RELAYER_B),
@@ -484,7 +495,7 @@ mod tests {
#[test]
fn rejects_same_message_from_two_different_relayers() {
run_test(|| {
- let mut lane = inbound_lane::(TEST_LANE_ID);
+ let mut lane = active_inbound_lane::(test_lane_id()).unwrap();
assert_eq!(
lane.receive_message::(
&TEST_RELAYER_A,
@@ -507,16 +518,16 @@ mod tests {
#[test]
fn correct_message_is_processed_instantly() {
run_test(|| {
- let mut lane = inbound_lane::(TEST_LANE_ID);
+ let mut lane = active_inbound_lane::(test_lane_id()).unwrap();
receive_regular_message(&mut lane, 1);
- assert_eq!(lane.storage.get_or_init_data().last_delivered_nonce(), 1);
+ assert_eq!(lane.storage.data().last_delivered_nonce(), 1);
});
}
#[test]
fn unspent_weight_is_returned_by_receive_message() {
run_test(|| {
- let mut lane = inbound_lane::(TEST_LANE_ID);
+ let mut lane = active_inbound_lane::(test_lane_id()).unwrap();
let mut payload = REGULAR_PAYLOAD;
*payload.dispatch_result.unspent_weight.ref_time_mut() = 1;
assert_eq!(
@@ -533,7 +544,7 @@ mod tests {
#[test]
fn first_message_is_confirmed_correctly() {
run_test(|| {
- let mut lane = inbound_lane::(TEST_LANE_ID);
+ let mut lane = active_inbound_lane::(test_lane_id()).unwrap();
receive_regular_message(&mut lane, 1);
receive_regular_message(&mut lane, 2);
assert_eq!(
@@ -544,7 +555,7 @@ mod tests {
Some(1),
);
assert_eq!(
- inbound_unrewarded_relayers_state(TEST_LANE_ID),
+ inbound_unrewarded_relayers_state(test_lane_id()),
UnrewardedRelayersState {
unrewarded_relayer_entries: 1,
messages_in_oldest_entry: 1,
diff --git a/bridges/modules/messages/src/lanes_manager.rs b/bridges/modules/messages/src/lanes_manager.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4f5ac1c0a40325d9f15279bc84a3753e185b92fc
--- /dev/null
+++ b/bridges/modules/messages/src/lanes_manager.rs
@@ -0,0 +1,283 @@
+// 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 (PhantomData<(T, I)>);
+
+impl, I: 'static> Default for LanesManager {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl, I: 'static> LanesManager {
+ /// Create new lanes manager.
+ pub fn new() -> Self {
+ Self(PhantomData)
+ }
+
+ /// Create new inbound lane in `Opened` state.
+ pub fn create_inbound_lane(
+ &self,
+ lane_id: LaneId,
+ ) -> Result>, LanesManagerError> {
+ InboundLanes::::try_mutate(lane_id, |lane| match lane {
+ Some(_) => Err(LanesManagerError::InboundLaneAlreadyExists),
+ None => {
+ *lane = Some(StoredInboundLaneData(InboundLaneData {
+ state: LaneState::Opened,
+ ..Default::default()
+ }));
+ Ok(())
+ },
+ })?;
+
+ self.active_inbound_lane(lane_id)
+ }
+
+ /// Create new outbound lane in `Opened` state.
+ pub fn create_outbound_lane(
+ &self,
+ lane_id: LaneId,
+ ) -> Result>, LanesManagerError> {
+ OutboundLanes::::try_mutate(lane_id, |lane| match lane {
+ Some(_) => Err(LanesManagerError::OutboundLaneAlreadyExists),
+ None => {
+ *lane = Some(OutboundLaneData { state: LaneState::Opened, ..Default::default() });
+ Ok(())
+ },
+ })?;
+
+ self.active_outbound_lane(lane_id)
+ }
+
+ /// Get existing inbound lane, checking that it is in usable state.
+ pub fn active_inbound_lane(
+ &self,
+ lane_id: LaneId,
+ ) -> Result>, LanesManagerError> {
+ Ok(InboundLane::new(RuntimeInboundLaneStorage::from_lane_id(lane_id, true)?))
+ }
+
+ /// Get existing outbound lane, checking that it is in usable state.
+ pub fn active_outbound_lane(
+ &self,
+ lane_id: LaneId,
+ ) -> Result>, LanesManagerError> {
+ Ok(OutboundLane::new(RuntimeOutboundLaneStorage::from_lane_id(lane_id, true)?))
+ }
+
+ /// Get existing inbound lane without any additional state checks.
+ pub fn any_state_inbound_lane(
+ &self,
+ lane_id: LaneId,
+ ) -> Result>, LanesManagerError> {
+ Ok(InboundLane::new(RuntimeInboundLaneStorage::from_lane_id(lane_id, false)?))
+ }
+
+ /// Get existing outbound lane without any additional state checks.
+ pub fn any_state_outbound_lane(
+ &self,
+ lane_id: LaneId,
+ ) -> Result>, LanesManagerError> {
+ Ok(OutboundLane::new(RuntimeOutboundLaneStorage::from_lane_id(lane_id, false)?))
+ }
+}
+
+/// Runtime inbound lane storage.
+pub struct RuntimeInboundLaneStorage, I: 'static = ()> {
+ pub(crate) lane_id: LaneId,
+ pub(crate) cached_data: InboundLaneData>>,
+}
+
+impl, I: 'static> RuntimeInboundLaneStorage {
+ /// Creates new runtime inbound lane storage for given **existing** lane.
+ fn from_lane_id(
+ lane_id: LaneId,
+ check_active: bool,
+ ) -> Result, LanesManagerError> {
+ let cached_data =
+ InboundLanes::::get(lane_id).ok_or(LanesManagerError::UnknownInboundLane)?;
+
+ if check_active {
+ // check that the lane is not explicitly closed
+ ensure!(cached_data.state.is_active(), LanesManagerError::ClosedInboundLane);
+ // apart from the explicit closure, the lane may be unable to receive any messages.
+ // Right now we do an additional check here, but it may be done later (e.g. by
+ // explicitly closing the lane and reopening it from
+ // `pallet-xcm-bridge-hub::on-initialize`)
+ //
+ // The fact that we only check it here, means that the `MessageDispatch` may switch
+ // to inactive state during some message dispatch in the middle of message delivery
+ // transaction. But we treat result of `MessageDispatch::is_active()` as a hint, so
+ // we know that it won't drop messages - just it experiences problems with processing.
+ // This would allow us to check that in our signed extensions, and invalidate
+ // transaction early, thus avoiding losing honest relayers funds. This problem should
+ // gone with relayers coordination protocol.
+ //
+ // There's a limit on number of messages in the message delivery transaction, so even
+ // if we dispatch (enqueue) some additional messages, we'll know the maximal queue
+ // length;
+ ensure!(
+ T::MessageDispatch::is_active(lane_id),
+ LanesManagerError::LaneDispatcherInactive
+ );
+ }
+
+ Ok(RuntimeInboundLaneStorage { lane_id, cached_data: cached_data.into() })
+ }
+
+ /// Returns number of bytes that may be subtracted from the PoV component of
+ /// `receive_messages_proof` call, because the actual inbound lane state is smaller than the
+ /// maximal configured.
+ ///
+ /// Maximal inbound lane state set size is configured by the
+ /// `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(&self) -> u64 {
+ let max_encoded_len = StoredInboundLaneData::::max_encoded_len();
+ let relayers_count = self.data().relayers.len();
+ let actual_encoded_len =
+ 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 = AccountIdOf>;
+
+ fn id(&self) -> LaneId {
+ self.lane_id
+ }
+
+ fn max_unrewarded_relayer_entries(&self) -> MessageNonce {
+ BridgedChainOf::
+
+# {name}
+
+This crate is part of the [Polkadot SDK](https://github.com/paritytech/polkadot-sdk/).
+
+