Merge branch 'develop' into account_mpts

ci: Use XRPLF/get-nproc (#2727 )
ci: Better pre-commit failure message (#2720 )
2025-11-04 11:55:51 +00:00 · 2025-10-28 11:23:32 -04:00 · 2025-10-27 18:50:40 +00:00 · 2025-10-27 12:14:56 +00:00 · 2025-10-27 10:17:41 +00:00 · 2025-10-27 10:16:14 +00:00
40 changed files with 2568 additions and 151 deletions
--- a/.github/actions/build-clio/action.yml
+++ b/.github/actions/build-clio/action.yml
@@ -5,25 +5,27 @@ inputs:
  targets:
    description: Space-separated build target names
    default: all
-  subtract_threads:
-    description: An option for the action get-threads-number.
+  nproc_subtract:
+    description: The number of processors to subtract when calculating parallelism.
    required: true
    default: "0"

 runs:
  using: composite
  steps:
-    - name: Get number of threads
-      uses: ./.github/actions/get-threads-number
-      id: number_of_threads
+    - name: Get number of processors
+      uses: XRPLF/actions/.github/actions/get-nproc@046b1620f6bfd6cd0985dc82c3df02786801fe0a
+      id: nproc
      with:
-        subtract_threads: ${{ inputs.subtract_threads }}
+        subtract: ${{ inputs.nproc_subtract }}

    - name: Build targets
      shell: bash
+      env:
+        CMAKE_TARGETS: ${{ inputs.targets }}
      run: |
        cd build
        cmake \
          --build . \
-          --parallel "${{ steps.number_of_threads.outputs.threads_number }}" \
-          --target ${{ inputs.targets }}
+          --parallel "${{ steps.nproc.outputs.nproc }}" \
+          --target ${CMAKE_TARGETS}
--- a/.github/actions/code-coverage/action.yml
+++ b/.github/actions/code-coverage/action.yml
@@ -24,7 +24,7 @@ runs:
          -j8 --exclude-throw-branches

    - name: Archive coverage report
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
      with:
        name: coverage-report.xml
        path: build/coverage_report.xml
--- a/.github/actions/create-issue/action.yml
+++ b/.github/actions/create-issue/action.yml
@@ -28,12 +28,17 @@ runs:
    - name: Create an issue
      id: create_issue
      shell: bash
+      env:
+        ISSUE_BODY: ${{ inputs.body }}
+        ISSUE_ASSIGNEES: ${{ inputs.assignees }}
+        ISSUE_LABELS: ${{ inputs.labels }}
+        ISSUE_TITLE: ${{ inputs.title }}
      run: |
-        echo -e '${{ inputs.body }}' > issue.md
+        echo -e "${ISSUE_BODY}" > issue.md
        gh issue create \
-          --assignee '${{ inputs.assignees }}' \
-          --label '${{ inputs.labels }}' \
-          --title '${{ inputs.title }}' \
+          --assignee "${ISSUE_ASSIGNEES}" \
+          --label "${ISSUE_LABELS}" \
+          --title "${ISSUE_TITLE}" \
          --body-file ./issue.md \
          > create_issue.log
        created_issue="$(sed 's|.*/||' create_issue.log)"
--- a/.github/actions/get-threads-number/action.yml
+++ b/.github/actions/get-threads-number/action.yml
@@ -1,36 +0,0 @@
-name: Get number of threads
-description: Determines number of threads to use on macOS and Linux
-
-inputs:
-  subtract_threads:
-    description: How many threads to subtract from the calculated number
-    required: true
-    default: "0"
-outputs:
-  threads_number:
-    description: Number of threads to use
-    value: ${{ steps.number_of_threads_export.outputs.num }}
-
-runs:
-  using: composite
-  steps:
-    - name: Get number of threads on mac
-      id: mac_threads
-      if: ${{ runner.os == 'macOS' }}
-      shell: bash
-      run: echo "num=$(($(sysctl -n hw.logicalcpu) - 2))" >> $GITHUB_OUTPUT
-
-    - name: Get number of threads on Linux
-      id: linux_threads
-      if: ${{ runner.os == 'Linux' }}
-      shell: bash
-      run: echo "num=$(($(nproc) - 2))" >> $GITHUB_OUTPUT
-
-    - name: Shift and export number of threads
-      id: number_of_threads_export
-      shell: bash
-      run: |
-        num_of_threads="${{ steps.mac_threads.outputs.num || steps.linux_threads.outputs.num }}"
-        shift_by="${{ inputs.subtract_threads }}"
-        shifted="$((num_of_threads - shift_by))"
-        echo "num=$(( shifted > 1 ? shifted : 1 ))" >> $GITHUB_OUTPUT
--- a/.github/actions/restore-cache/action.yml
+++ b/.github/actions/restore-cache/action.yml
@@ -30,7 +30,7 @@ runs:
      uses: ./.github/actions/git-common-ancestor

    - name: Restore ccache cache
-      uses: actions/cache/restore@v4
+      uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
      id: ccache_cache
      if: ${{ env.CCACHE_DISABLE != '1' }}
      with:
--- a/.github/actions/save-cache/action.yml
+++ b/.github/actions/save-cache/action.yml
@@ -32,7 +32,7 @@ runs:

    - name: Save ccache cache
      if: ${{ inputs.ccache_cache_hit != 'true' || inputs.ccache_cache_miss_rate == '100.0' }}
-      uses: actions/cache/save@v4
+      uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
      with:
        path: ${{ inputs.ccache_dir }}
        key: clio-ccache-${{ runner.os }}-${{ inputs.build_type }}${{ inputs.code_coverage == 'true' && '-code_coverage' || '' }}-${{ inputs.conan_profile }}-develop-${{ steps.git_common_ancestor.outputs.commit }}
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -91,19 +91,6 @@ updates:
      prefix: "ci: [DEPENDABOT] "
    target-branch: develop

-  - package-ecosystem: github-actions
-    directory: .github/actions/get-threads-number/
-    schedule:
-      interval: weekly
-      day: monday
-      time: "04:00"
-      timezone: Etc/GMT
-    reviewers:
-      - XRPLF/clio-dev-team
-    commit-message:
-      prefix: "ci: [DEPENDABOT] "
-    target-branch: develop
-
  - package-ecosystem: github-actions
    directory: .github/actions/git-common-ancestor/
    schedule:
--- a/.github/scripts/execute-tests-under-sanitizer.sh
+++ b/.github/scripts/execute-tests-under-sanitizer.sh
@@ -31,15 +31,16 @@ TESTS=$($TEST_BINARY --gtest_list_tests | awk '/^  / {print suite $1} !/^  / {su
 OUTPUT_DIR="./.sanitizer-report"
 mkdir -p "$OUTPUT_DIR"

+export TSAN_OPTIONS="die_after_fork=0"
+export MallocNanoZone='0' # for MacOSX
+
 for TEST in $TESTS; do
-  OUTPUT_FILE="$OUTPUT_DIR/${TEST//\//_}"
-  export TSAN_OPTIONS="log_path=\"$OUTPUT_FILE\" die_after_fork=0"
-  export ASAN_OPTIONS="log_path=\"$OUTPUT_FILE\""
-  export UBSAN_OPTIONS="log_path=\"$OUTPUT_FILE\""
-  export MallocNanoZone='0' # for MacOSX
-  $TEST_BINARY --gtest_filter="$TEST" > /dev/null 2>&1
+  OUTPUT_FILE="$OUTPUT_DIR/${TEST//\//_}.log"
+  $TEST_BINARY --gtest_filter="$TEST" > "$OUTPUT_FILE" 2>&1

  if [ $? -ne 0 ]; then
    echo "'$TEST' failed a sanitizer check."
+  else
+    rm "$OUTPUT_FILE"
  fi
 done
--- a/.github/workflows/build-clio-docker-image.yml
+++ b/.github/workflows/build-clio-docker-image.yml
@@ -44,11 +44,11 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Download Clio binary from artifact
        if: ${{ inputs.artifact_name != null }}
-        uses: actions/download-artifact@v5
+        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
        with:
          name: ${{ inputs.artifact_name }}
          path: ./docker/clio/artifact/
@@ -56,9 +56,12 @@ jobs:
      - name: Download Clio binary from url
        if: ${{ inputs.clio_server_binary_url != null }}
        shell: bash
+        env:
+          BINARY_URL: ${{ inputs.clio_server_binary_url }}
+          BINARY_SHA256: ${{ inputs.binary_sha256 }}
        run: |
-          wget "${{inputs.clio_server_binary_url}}" -P ./docker/clio/artifact/
-          if [ "$(sha256sum ./docker/clio/clio_server | awk '{print $1}')" != "${{inputs.binary_sha256}}" ]; then
+          wget "${BINARY_URL}" -P ./docker/clio/artifact/
+          if [ "$(sha256sum ./docker/clio/clio_server | awk '{print $1}')" != "${BINARY_SHA256}" ]; then
            echo "Binary sha256 sum doesn't match"
            exit 1
          fi
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -114,9 +114,9 @@ jobs:
      image: ghcr.io/xrplf/clio-ci:b2be4b51d1d81548ca48e2f2b8f67356b880c96d

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
        with:
          name: clio_server_Linux_Release_gcc

--- a/.github/workflows/check-libxrpl.yml
+++ b/.github/workflows/check-libxrpl.yml
@@ -20,7 +20,7 @@ jobs:
      image: ghcr.io/xrplf/clio-ci:b2be4b51d1d81548ca48e2f2b8f67356b880c96d

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
        with:
          fetch-depth: 0

@@ -57,7 +57,7 @@ jobs:
        run: strip build/clio_tests

      - name: Upload clio_tests
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
        with:
          name: clio_tests_check_libxrpl
          path: build/clio_tests
@@ -70,7 +70,7 @@ jobs:
      image: ghcr.io/xrplf/clio-ci:b2be4b51d1d81548ca48e2f2b8f67356b880c96d

    steps:
-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
        with:
          name: clio_tests_check_libxrpl

@@ -90,7 +90,7 @@ jobs:
      issues: write

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Create an issue
        uses: ./.github/actions/create-issue
--- a/.github/workflows/check-pr-title.yml
+++ b/.github/workflows/check-pr-title.yml
@@ -10,15 +10,17 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - uses: ytanikin/pr-conventional-commits@b72758283dcbee706975950e96bc4bf323a8d8c0 # v1.4.2
+      - uses: ytanikin/pr-conventional-commits@b72758283dcbee706975950e96bc4bf323a8d8c0 # 1.4.2
        with:
          task_types: '["build","feat","fix","docs","test","ci","style","refactor","perf","chore"]'
          add_label: false
          custom_labels: '{"build":"build", "feat":"enhancement", "fix":"bug", "docs":"documentation", "test":"testability", "ci":"ci", "style":"refactoring", "refactor":"refactoring", "perf":"performance", "chore":"tooling"}'

      - name: Check if message starts with upper-case letter
+        env:
+          PR_TITLE: ${{ github.event.pull_request.title }}
        run: |
-          if [[ ! "${{ github.event.pull_request.title }}" =~ ^[a-z]+:\ [\[A-Z] ]]; then
+          if [[ ! "${PR_TITLE}" =~ ^[a-z]+:\ [\[A-Z] ]]; then
            echo "Error: PR title must start with an upper-case letter."
            exit 1
          fi
--- a/.github/workflows/clang-tidy.yml
+++ b/.github/workflows/clang-tidy.yml
@@ -35,7 +35,7 @@ jobs:
      pull-requests: write

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
        with:
          fetch-depth: 0

@@ -61,16 +61,16 @@ jobs:
        with:
          conan_profile: ${{ env.CONAN_PROFILE }}

-      - name: Get number of threads
-        uses: ./.github/actions/get-threads-number
-        id: number_of_threads
+      - name: Get number of processors
+        uses: XRPLF/actions/.github/actions/get-nproc@046b1620f6bfd6cd0985dc82c3df02786801fe0a
+        id: nproc

      - name: Run clang-tidy
        continue-on-error: true
        shell: bash
        id: run_clang_tidy
        run: |
-          run-clang-tidy-${{ env.LLVM_TOOLS_VERSION }} -p build -j "${{ steps.number_of_threads.outputs.threads_number }}" -fix -quiet 1>output.txt
+          run-clang-tidy-${{ env.LLVM_TOOLS_VERSION }} -p build -j "${{ steps.nproc.outputs.nproc }}" -fix -quiet 1>output.txt

      - name: Fix local includes and clang-format style
        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -18,7 +18,7 @@ jobs:

    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
        with:
          lfs: true

@@ -39,10 +39,10 @@ jobs:
        run: cmake --build . --target docs

      - name: Setup Pages
-        uses: actions/configure-pages@v5
+        uses: actions/configure-pages@983d7736d9b0ae728b81ab479565c72886d7745b # v5.0.0

      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v4
+        uses: actions/upload-pages-artifact@7b1f4a764d45c48632c6b24a0339c27f5614fb0b # v4.0.0
        with:
          path: build_docs/html
          name: docs-develop
@@ -62,6 +62,6 @@ jobs:
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4.0.5
        with:
          artifact_name: docs-develop
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -130,7 +130,7 @@ jobs:
      issues: write

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Create an issue
        uses: ./.github/actions/create-issue
--- a/.github/workflows/pre-commit.yml
+++ b/.github/workflows/pre-commit.yml
@@ -8,7 +8,7 @@ on:

 jobs:
  run-hooks:
-    uses: XRPLF/actions/.github/workflows/pre-commit.yml@a8d7472b450eb53a1e5228f64552e5974457a21a
+    uses: XRPLF/actions/.github/workflows/pre-commit.yml@34790936fae4c6c751f62ec8c06696f9c1a5753a
    with:
      runs_on: heavy
      container: '{ "image": "ghcr.io/xrplf/clio-pre-commit:b2be4b51d1d81548ca48e2f2b8f67356b880c96d" }'
--- a/.github/workflows/reusable-build.yml
+++ b/.github/workflows/reusable-build.yml
@@ -86,7 +86,7 @@ jobs:
        if: ${{ runner.os == 'macOS' }}
        uses: XRPLF/actions/.github/actions/cleanup-workspace@ea9970b7c211b18f4c8bcdb28c29f5711752029f

-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
        with:
          fetch-depth: 0
          # We need to fetch tags to have correct version in the release
@@ -145,7 +145,7 @@ jobs:

      - name: Upload build time analyze report
        if: ${{ inputs.analyze_build_time }}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
        with:
          name: build_time_report_${{ runner.os }}_${{ inputs.build_type }}_${{ inputs.conan_profile }}
          path: build_time_report.txt
@@ -170,28 +170,28 @@ jobs:

      - name: Upload clio_server
        if: ${{ inputs.upload_clio_server && !inputs.code_coverage && !inputs.analyze_build_time }}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
        with:
          name: clio_server_${{ runner.os }}_${{ inputs.build_type }}_${{ inputs.conan_profile }}
          path: build/clio_server

      - name: Upload clio_tests
        if: ${{ !inputs.code_coverage && !inputs.analyze_build_time && !inputs.package }}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
        with:
          name: clio_tests_${{ runner.os }}_${{ inputs.build_type }}_${{ inputs.conan_profile }}
          path: build/clio_tests

      - name: Upload clio_integration_tests
        if: ${{ !inputs.code_coverage && !inputs.analyze_build_time && !inputs.package }}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
        with:
          name: clio_integration_tests_${{ runner.os }}_${{ inputs.build_type }}_${{ inputs.conan_profile }}
          path: build/clio_integration_tests

      - name: Upload Clio Linux package
        if: ${{ inputs.package }}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
        with:
          name: clio_deb_package_${{ runner.os }}_${{ inputs.build_type }}_${{ inputs.conan_profile }}
          path: build/*.deb
@@ -221,12 +221,14 @@ jobs:
      - name: Verify expected version
        if: ${{ inputs.expected_version != '' }}
        shell: bash
+        env:
+          INPUT_EXPECTED_VERSION: ${{ inputs.expected_version }}
        run: |
          set -e
-          EXPECTED_VERSION="clio-${{ inputs.expected_version }}"
+          EXPECTED_VERSION="clio-${INPUT_EXPECTED_VERSION}"
          actual_version=$(./build/clio_server --version)
          if [[ "$actual_version" != "$EXPECTED_VERSION" ]]; then
-            echo "Expected version '$EXPECTED_VERSION', but got '$actual_version'"
+            echo "Expected version '${EXPECTED_VERSION}', but got '${actual_version}'"
            exit 1
          fi

--- a/.github/workflows/reusable-release.yml
+++ b/.github/workflows/reusable-release.yml
@@ -51,7 +51,7 @@ jobs:
      contents: write

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
        with:
          fetch-depth: 0

@@ -60,17 +60,19 @@ jobs:
        with:
          disable_ccache: true

-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
        with:
          path: release_artifacts
          pattern: clio_server_*

      - name: Create release notes
        shell: bash
+        env:
+          RELEASE_HEADER: ${{ inputs.header }}
        run: |
          echo "# Release notes" > "${RUNNER_TEMP}/release_notes.md"
          echo "" >> "${RUNNER_TEMP}/release_notes.md"
-          printf '%s\n' "${{ inputs.header }}" >> "${RUNNER_TEMP}/release_notes.md"
+          printf '%s\n' "${RELEASE_HEADER}" >> "${RUNNER_TEMP}/release_notes.md"

      - name: Generate changelog
        shell: bash
@@ -87,7 +89,7 @@ jobs:
        run: .github/scripts/prepare-release-artifacts.sh release_artifacts

      - name: Upload release notes
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
        with:
          name: release_notes_${{ inputs.version }}
          path: "${RUNNER_TEMP}/release_notes.md"
@@ -95,18 +97,25 @@ jobs:
      - name: Remove current release and tag
        if: ${{ github.event_name != 'pull_request' && inputs.overwrite_release }}
        shell: bash
+        env:
+          RELEASE_VERSION: ${{ inputs.version }}
        run: |
-          gh release delete ${{ inputs.version }} --yes || true
-          git push origin :${{ inputs.version }} || true
+          gh release delete "${RELEASE_VERSION}" --yes || true
+          git push origin :"${RELEASE_VERSION}" || true

      - name: Publish release
        if: ${{ github.event_name != 'pull_request' }}
        shell: bash
+        env:
+          RELEASE_VERSION: ${{ inputs.version }}
+          PRERELEASE_OPTION: ${{ inputs.prerelease && '--prerelease' || '' }}
+          RELEASE_TITLE: ${{ inputs.title }}
+          DRAFT_OPTION: ${{ inputs.draft && '--draft' || '' }}
        run: |
-          gh release create "${{ inputs.version }}" \
-            ${{ inputs.prerelease && '--prerelease' || '' }} \
-            --title "${{ inputs.title }}" \
+          gh release create "${RELEASE_VERSION}" \
+            ${PRERELEASE_OPTION} \
+            --title "${RELEASE_TITLE}" \
            --target "${GITHUB_SHA}" \
-            ${{ inputs.draft && '--draft' || '' }} \
+            ${DRAFT_OPTION} \
            --notes-file "${RUNNER_TEMP}/release_notes.md" \
            ./release_artifacts/clio_server*
--- a/.github/workflows/reusable-test.yml
+++ b/.github/workflows/reusable-test.yml
@@ -43,18 +43,18 @@ jobs:

    env:
      # TODO: remove completely when we have fixed all currently existing issues with sanitizers
-      SANITIZER_IGNORE_ERRORS: ${{ endsWith(inputs.conan_profile, '.tsan') || inputs.conan_profile == 'clang.asan' || (inputs.conan_profile == 'gcc.asan' && inputs.build_type == 'Release') }}
+      SANITIZER_IGNORE_ERRORS: ${{ endsWith(inputs.conan_profile, '.tsan') || (inputs.conan_profile == 'gcc.asan' && inputs.build_type == 'Release') }}

    steps:
      - name: Cleanup workspace
        if: ${{ runner.os == 'macOS' }}
        uses: XRPLF/actions/.github/actions/cleanup-workspace@ea9970b7c211b18f4c8bcdb28c29f5711752029f

-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
        with:
          fetch-depth: 0

-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
        with:
          name: clio_tests_${{ runner.os }}_${{ inputs.build_type }}_${{ inputs.conan_profile }}

@@ -68,7 +68,7 @@ jobs:

      - name: Run clio_tests (sanitizer errors ignored)
        if: ${{ env.SANITIZER_IGNORE_ERRORS == 'true' }}
-        run: ./.github/scripts/execute-tests-under-sanitizer ./clio_tests
+        run: ./.github/scripts/execute-tests-under-sanitizer.sh ./clio_tests

      - name: Check for sanitizer report
        if: ${{ env.SANITIZER_IGNORE_ERRORS == 'true' }}
@@ -83,7 +83,7 @@ jobs:

      - name: Upload sanitizer report
        if: ${{ env.SANITIZER_IGNORE_ERRORS == 'true' && steps.check_report.outputs.found_report == 'true' }}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
        with:
          name: sanitizer_report_${{ runner.os }}_${{ inputs.build_type }}_${{ inputs.conan_profile }}
          path: .sanitizer-report/*
@@ -144,7 +144,7 @@ jobs:
            sleep 5
          done

-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
        with:
          name: clio_integration_tests_${{ runner.os }}_${{ inputs.build_type }}_${{ inputs.conan_profile }}

--- a/.github/workflows/reusable-upload-coverage-report.yml
+++ b/.github/workflows/reusable-upload-coverage-report.yml
@@ -12,12 +12,12 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
        with:
          fetch-depth: 0

      - name: Download report artifact
-        uses: actions/download-artifact@v5
+        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
        with:
          name: coverage-report.xml
          path: build
--- a/.github/workflows/sanitizers.yml
+++ b/.github/workflows/sanitizers.yml
@@ -15,7 +15,7 @@ on:
      - ".github/actions/**"
      - "!.github/actions/build-docker-image/**"
      - "!.github/actions/create-issue/**"
-      - .github/scripts/execute-tests-under-sanitizer
+      - .github/scripts/execute-tests-under-sanitizer.sh

      - CMakeLists.txt
      - conanfile.py
--- a/.github/workflows/update-docker-ci.yml
+++ b/.github/workflows/update-docker-ci.yml
@@ -52,7 +52,7 @@ jobs:
    needs: repo

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Get changed files
        id: changed-files
@@ -90,7 +90,7 @@ jobs:
    needs: repo

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Get changed files
        id: changed-files
@@ -128,7 +128,7 @@ jobs:
    needs: [repo, gcc-amd64, gcc-arm64]

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Get changed files
        id: changed-files
@@ -137,7 +137,7 @@ jobs:
          files: "docker/compilers/gcc/**"

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.11.1

      - name: Login to GitHub Container Registry
        if: ${{ github.event_name != 'pull_request' }}
@@ -179,7 +179,7 @@ jobs:
    needs: repo

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Get changed files
        id: changed-files
@@ -215,7 +215,7 @@ jobs:
    needs: [repo, gcc-merge]

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Get changed files
        id: changed-files
@@ -246,7 +246,7 @@ jobs:
    needs: [repo, gcc-merge]

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Get changed files
        id: changed-files
@@ -277,7 +277,7 @@ jobs:
    needs: [repo, tools-amd64, tools-arm64]

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Get changed files
        id: changed-files
@@ -286,7 +286,7 @@ jobs:
          files: "docker/tools/**"

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.11.1

      - name: Login to GitHub Container Registry
        if: ${{ github.event_name != 'pull_request' }}
@@ -312,7 +312,7 @@ jobs:
    needs: [repo, tools-merge]

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
      - uses: ./.github/actions/build-docker-image
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -334,7 +334,7 @@ jobs:
    needs: [repo, gcc-merge, clang, tools-merge]

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
      - uses: ./.github/actions/build-docker-image
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/upload-conan-deps.yml
+++ b/.github/workflows/upload-conan-deps.yml
@@ -46,7 +46,7 @@ jobs:
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Calculate conan matrix
        id: set-matrix
@@ -69,7 +69,7 @@ jobs:
      CONAN_PROFILE: ${{ matrix.compiler }}${{ matrix.sanitizer_ext }}

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Prepare runner
        uses: XRPLF/actions/.github/actions/prepare-runner@7951b682e5a2973b28b0719a72f01fc4b0d0c34f
@@ -99,4 +99,6 @@ jobs:

      - name: Upload Conan packages
        if: ${{ github.repository_owner == 'XRPLF' && github.event_name != 'pull_request' && github.event_name != 'schedule' }}
-        run: conan upload "*" -r=xrplf --confirm ${{ github.event.inputs.force_upload == 'true' && '--force' || '' }}
+        env:
+          FORCE_OPTION: ${{ github.event.inputs.force_upload == 'true' && '--force' || '' }}
+        run: conan upload "*" -r=xrplf --confirm ${FORCE_OPTION}
--- a/README.md
+++ b/README.md
@@ -34,7 +34,6 @@ Below are some useful docs to learn more about Clio.

 - [How to configure Clio and rippled](./docs/configure-clio.md)
 - [How to run Clio](./docs/run-clio.md)
- [Logging](./docs/logging.md)
 - [Troubleshooting guide](./docs/trouble_shooting.md)

 **General reference material:**
--- a/src/rpc/CMakeLists.txt
+++ b/src/rpc/CMakeLists.txt
@@ -24,6 +24,8 @@ target_sources(
          handlers/AccountCurrencies.cpp
          handlers/AccountInfo.cpp
          handlers/AccountLines.cpp
+          handlers/AccountMPTokenIssuances.cpp
+          handlers/AccountMPTokens.cpp
          handlers/AccountNFTs.cpp
          handlers/AccountObjects.cpp
          handlers/AccountOffers.cpp
--- a/src/rpc/RPCCenter.cpp
+++ b/src/rpc/RPCCenter.cpp
@@ -35,6 +35,8 @@ handledRpcs()
        "account_currencies",
        "account_info",
        "account_lines",
+        "account_mptoken_issuances",
+        "account_mptokens",
        "account_nfts",
        "account_objects",
        "account_offers",
--- a/src/rpc/common/impl/HandlerProvider.cpp
+++ b/src/rpc/common/impl/HandlerProvider.cpp
@@ -31,6 +31,8 @@
 #include "rpc/handlers/AccountCurrencies.hpp"
 #include "rpc/handlers/AccountInfo.hpp"
 #include "rpc/handlers/AccountLines.hpp"
+#include "rpc/handlers/AccountMPTokenIssuances.hpp"
+#include "rpc/handlers/AccountMPTokens.hpp"
 #include "rpc/handlers/AccountNFTs.hpp"
 #include "rpc/handlers/AccountObjects.hpp"
 #include "rpc/handlers/AccountOffers.hpp"
@@ -85,6 +87,9 @@ ProductionHandlerProvider::ProductionHandlerProvider(
          {"account_currencies", {.handler = AccountCurrenciesHandler{backend}}},
          {"account_info", {.handler = AccountInfoHandler{backend, amendmentCenter}}},
          {"account_lines", {.handler = AccountLinesHandler{backend}}},
+          {"account_mptoken_issuances",
+           {.handler = AccountMPTokenIssuancesHandler{backend}, .isClioOnly = true}},              // clio only
+          {"account_mptokens", {.handler = AccountMPTokensHandler{backend}, .isClioOnly = true}},  // clio only
          {"account_nfts", {.handler = AccountNFTsHandler{backend}}},
          {"account_objects", {.handler = AccountObjectsHandler{backend}}},
          {"account_offers", {.handler = AccountOffersHandler{backend}}},
--- a/src/rpc/handlers/AccountMPTokenIssuances.cpp
+++ b/src/rpc/handlers/AccountMPTokenIssuances.cpp
@@ -0,0 +1,237 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include "rpc/handlers/AccountMPTokenIssuances.hpp"
+
+#include "rpc/Errors.hpp"
+#include "rpc/JS.hpp"
+#include "rpc/RPCHelpers.hpp"
+#include "rpc/common/Types.hpp"
+#include "util/Assert.hpp"
+#include "util/JsonUtils.hpp"
+
+#include <boost/json/conversion.hpp>
+#include <boost/json/object.hpp>
+#include <boost/json/value.hpp>
+#include <boost/json/value_to.hpp>
+#include <xrpl/basics/strHex.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/LedgerHeader.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/UintTypes.h>
+#include <xrpl/protocol/jss.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace rpc {
+
+void
+AccountMPTokenIssuancesHandler::addMPTokenIssuance(
+    std::vector<MPTokenIssuanceResponse>& issuances,
+    ripple::SLE const& sle,
+    ripple::AccountID const& account
+)
+{
+    MPTokenIssuanceResponse issuance;
+
+    issuance.issuer = ripple::to_string(account);
+    issuance.sequence = sle.getFieldU32(ripple::sfSequence);
+    auto const flags = sle.getFieldU32(ripple::sfFlags);
+
+    auto const setFlag = [&](std::optional<bool>& field, std::uint32_t mask) {
+        if ((flags & mask) != 0u)
+            field = true;
+    };
+
+    setFlag(issuance.mptLocked, ripple::lsfMPTLocked);
+    setFlag(issuance.mptCanLock, ripple::lsfMPTCanLock);
+    setFlag(issuance.mptRequireAuth, ripple::lsfMPTRequireAuth);
+    setFlag(issuance.mptCanEscrow, ripple::lsfMPTCanEscrow);
+    setFlag(issuance.mptCanTrade, ripple::lsfMPTCanTrade);
+    setFlag(issuance.mptCanTransfer, ripple::lsfMPTCanTransfer);
+    setFlag(issuance.mptCanClawback, ripple::lsfMPTCanClawback);
+
+    if (sle.isFieldPresent(ripple::sfTransferFee))
+        issuance.transferFee = sle.getFieldU16(ripple::sfTransferFee);
+
+    if (sle.isFieldPresent(ripple::sfAssetScale))
+        issuance.assetScale = sle.getFieldU8(ripple::sfAssetScale);
+
+    if (sle.isFieldPresent(ripple::sfMaximumAmount))
+        issuance.maximumAmount = sle.getFieldU64(ripple::sfMaximumAmount);
+
+    if (sle.isFieldPresent(ripple::sfOutstandingAmount))
+        issuance.outstandingAmount = sle.getFieldU64(ripple::sfOutstandingAmount);
+
+    if (sle.isFieldPresent(ripple::sfLockedAmount))
+        issuance.lockedAmount = sle.getFieldU64(ripple::sfLockedAmount);
+
+    if (sle.isFieldPresent(ripple::sfMPTokenMetadata))
+        issuance.mptokenMetadata = ripple::strHex(sle.getFieldVL(ripple::sfMPTokenMetadata));
+
+    if (sle.isFieldPresent(ripple::sfDomainID))
+        issuance.domainID = ripple::strHex(sle.getFieldH256(ripple::sfDomainID));
+
+    issuances.push_back(issuance);
+}
+
+AccountMPTokenIssuancesHandler::Result
+AccountMPTokenIssuancesHandler::process(AccountMPTokenIssuancesHandler::Input const& input, Context const& ctx) const
+{
+    auto const range = sharedPtrBackend_->fetchLedgerRange();
+    ASSERT(range.has_value(), "AccountMPTokenIssuances' ledger range must be available");
+    auto const expectedLgrInfo = getLedgerHeaderFromHashOrSeq(
+        *sharedPtrBackend_, ctx.yield, input.ledgerHash, input.ledgerIndex, range->maxSequence
+    );
+
+    if (!expectedLgrInfo.has_value())
+        return Error{expectedLgrInfo.error()};
+
+    auto const& lgrInfo = expectedLgrInfo.value();
+    auto const accountID = accountFromStringStrict(input.account);
+    auto const accountLedgerObject =
+        sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield);
+
+    if (not accountLedgerObject.has_value())
+        return Error{Status{RippledError::rpcACT_NOT_FOUND}};
+
+    Output response;
+    response.issuances.reserve(input.limit);
+
+    auto const addToResponse = [&](ripple::SLE const& sle) {
+        if (sle.getType() == ripple::ltMPTOKEN_ISSUANCE) {
+            addMPTokenIssuance(response.issuances, sle, *accountID);
+        }
+    };
+
+    auto const expectedNext = traverseOwnedNodes(
+        *sharedPtrBackend_, *accountID, lgrInfo.seq, input.limit, input.marker, ctx.yield, addToResponse
+    );
+
+    if (!expectedNext.has_value())
+        return Error{expectedNext.error()};
+
+    auto const nextMarker = expectedNext.value();
+
+    response.account = input.account;
+    response.limit = input.limit;
+
+    response.ledgerHash = ripple::strHex(lgrInfo.hash);
+    response.ledgerIndex = lgrInfo.seq;
+
+    if (nextMarker.isNonZero())
+        response.marker = nextMarker.toString();
+
+    return response;
+}
+
+AccountMPTokenIssuancesHandler::Input
+tag_invoke(boost::json::value_to_tag<AccountMPTokenIssuancesHandler::Input>, boost::json::value const& jv)
+{
+    auto input = AccountMPTokenIssuancesHandler::Input{};
+    auto const& jsonObject = jv.as_object();
+
+    input.account = boost::json::value_to<std::string>(jv.at(JS(account)));
+
+    if (jsonObject.contains(JS(limit)))
+        input.limit = util::integralValueAs<uint32_t>(jv.at(JS(limit)));
+
+    if (jsonObject.contains(JS(marker)))
+        input.marker = boost::json::value_to<std::string>(jv.at(JS(marker)));
+
+    if (jsonObject.contains(JS(ledger_hash)))
+        input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
+
+    if (jsonObject.contains(JS(ledger_index))) {
+        if (!jsonObject.at(JS(ledger_index)).is_string()) {
+            input.ledgerIndex = util::integralValueAs<uint32_t>(jv.at(JS(ledger_index)));
+        } else if (jsonObject.at(JS(ledger_index)).as_string() != "validated") {
+            input.ledgerIndex = std::stoi(boost::json::value_to<std::string>(jv.at(JS(ledger_index))));
+        }
+    }
+
+    return input;
+}
+
+void
+tag_invoke(boost::json::value_from_tag, boost::json::value& jv, AccountMPTokenIssuancesHandler::Output const& output)
+{
+    using boost::json::value_from;
+
+    auto obj = boost::json::object{
+        {JS(account), output.account},
+        {JS(ledger_hash), output.ledgerHash},
+        {JS(ledger_index), output.ledgerIndex},
+        {JS(validated), output.validated},
+        {JS(limit), output.limit},
+        {"mpt_issuances", value_from(output.issuances)},
+    };
+
+    if (output.marker.has_value())
+        obj[JS(marker)] = *output.marker;
+
+    jv = std::move(obj);
+}
+
+void
+tag_invoke(
+    boost::json::value_from_tag,
+    boost::json::value& jv,
+    AccountMPTokenIssuancesHandler::MPTokenIssuanceResponse const& issuance
+)
+{
+    auto obj = boost::json::object{
+        {JS(issuer), issuance.issuer},
+        {JS(sequence), issuance.sequence},
+    };
+
+    auto const setIfPresent = [&](boost::json::string_view field, auto const& value) {
+        if (value.has_value()) {
+            obj[field] = *value;
+        }
+    };
+
+    setIfPresent("transfer_fee", issuance.transferFee);
+    setIfPresent("asset_scale", issuance.assetScale);
+    setIfPresent("maximum_amount", issuance.maximumAmount);
+    setIfPresent("outstanding_amount", issuance.outstandingAmount);
+    setIfPresent("locked_amount", issuance.lockedAmount);
+    setIfPresent("mptoken_metadata", issuance.mptokenMetadata);
+    setIfPresent("domain_id", issuance.domainID);
+
+    setIfPresent("mpt_locked", issuance.mptLocked);
+    setIfPresent("mpt_can_lock", issuance.mptCanLock);
+    setIfPresent("mpt_require_auth", issuance.mptRequireAuth);
+    setIfPresent("mpt_can_escrow", issuance.mptCanEscrow);
+    setIfPresent("mpt_can_trade", issuance.mptCanTrade);
+    setIfPresent("mpt_can_transfer", issuance.mptCanTransfer);
+    setIfPresent("mpt_can_clawback", issuance.mptCanClawback);
+
+    jv = std::move(obj);
+}
+
+}  // namespace rpc
--- a/src/rpc/handlers/AccountMPTokenIssuances.hpp
+++ b/src/rpc/handlers/AccountMPTokenIssuances.hpp
@@ -0,0 +1,196 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "data/BackendInterface.hpp"
+#include "rpc/Errors.hpp"
+#include "rpc/JS.hpp"
+#include "rpc/common/Checkers.hpp"
+#include "rpc/common/MetaProcessors.hpp"
+#include "rpc/common/Modifiers.hpp"
+#include "rpc/common/Specs.hpp"
+#include "rpc/common/Types.hpp"
+#include "rpc/common/Validators.hpp"
+
+#include <boost/json/conversion.hpp>
+#include <boost/json/value.hpp>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/ErrorCodes.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/jss.h>
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace rpc {
+
+/**
+ * @brief The account_mptoken_issuances method returns information about all MPTokenIssuance objects the account has
+ * created.
+ */
+class AccountMPTokenIssuancesHandler {
+    // dependencies
+    std::shared_ptr<BackendInterface> sharedPtrBackend_;
+
+public:
+    static constexpr auto kLIMIT_MIN = 10;
+    static constexpr auto kLIMIT_MAX = 400;
+    static constexpr auto kLIMIT_DEFAULT = 200;
+
+    /**
+     * @brief A struct to hold data for one MPTokenIssuance response.
+     */
+    struct MPTokenIssuanceResponse {
+        std::string issuer;
+        uint32_t sequence{};
+
+        std::optional<uint16_t> transferFee{};
+        std::optional<uint8_t> assetScale{};
+
+        std::optional<std::uint64_t> maximumAmount;
+        std::optional<std::uint64_t> outstandingAmount;
+        std::optional<std::uint64_t> lockedAmount;
+        std::optional<std::string> mptokenMetadata;
+        std::optional<std::string> domainID;
+
+        std::optional<bool> mptLocked;
+        std::optional<bool> mptCanLock;
+        std::optional<bool> mptRequireAuth;
+        std::optional<bool> mptCanEscrow;
+        std::optional<bool> mptCanTrade;
+        std::optional<bool> mptCanTransfer;
+        std::optional<bool> mptCanClawback;
+    };
+
+    /**
+     * @brief A struct to hold the output data of the command.
+     */
+    struct Output {
+        std::string account;
+        std::vector<MPTokenIssuanceResponse> issuances;
+        std::string ledgerHash;
+        uint32_t ledgerIndex{};
+        bool validated = true;
+        std::optional<std::string> marker;
+        uint32_t limit{};
+    };
+
+    /**
+     * @brief A struct to hold the input data for the command.
+     */
+    struct Input {
+        std::string account;
+        std::optional<std::string> ledgerHash;
+        std::optional<uint32_t> ledgerIndex;
+        uint32_t limit = kLIMIT_DEFAULT;
+        std::optional<std::string> marker;
+    };
+
+    using Result = HandlerReturnType<Output>;
+
+    /**
+     * @brief Construct a new AccountMPTokenIssuancesHandler object.
+     *
+     * @param sharedPtrBackend The backend to use.
+     */
+    AccountMPTokenIssuancesHandler(std::shared_ptr<BackendInterface> sharedPtrBackend)
+        : sharedPtrBackend_(std::move(sharedPtrBackend))
+    {
+    }
+
+    /**
+     * @brief Returns the API specification for the command.
+     *
+     * @param apiVersion The API version to return the spec for.
+     * @return The spec for the given API version.
+     */
+    static RpcSpecConstRef
+    spec([[maybe_unused]] uint32_t apiVersion)
+    {
+        static auto const kRPC_SPEC = RpcSpec{
+            {JS(account),
+             validation::Required{},
+             meta::WithCustomError{
+                 validation::CustomValidators::accountValidator, Status(RippledError::rpcACT_MALFORMED)
+             }},
+            {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator},
+            {JS(limit),
+             validation::Type<uint32_t>{},
+             validation::Min(1u),
+             modifiers::Clamp<int32_t>{kLIMIT_MIN, kLIMIT_MAX}},
+            {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator},
+            {JS(marker), validation::CustomValidators::accountMarkerValidator},
+            {JS(ledger), check::Deprecated{}},
+        };
+
+        return kRPC_SPEC;
+    }
+
+    /**
+     * @brief Process the AccountMPTokenIssuances command.
+     *
+     * @param input The input data for the command.
+     * @param ctx The context of the request.
+     * @return The result of the operation.
+     */
+    Result
+    process(Input const& input, Context const& ctx) const;
+
+private:
+    static void
+    addMPTokenIssuance(
+        std::vector<MPTokenIssuanceResponse>& issuances,
+        ripple::SLE const& sle,
+        ripple::AccountID const& account
+    );
+
+private:
+    /**
+     * @brief Convert the Output to a JSON object
+     *
+     * @param [out] jv The JSON object to convert to
+     * @param output The output to convert
+     */
+    friend void
+    tag_invoke(boost::json::value_from_tag, boost::json::value& jv, Output const& output);
+
+    /**
+     * @brief Convert a JSON object to Input type
+     *
+     * @param jv The JSON object to convert
+     * @return Input parsed from the JSON object
+     */
+    friend Input
+    tag_invoke(boost::json::value_to_tag<Input>, boost::json::value const& jv);
+
+    /**
+     * @brief Convert the MPTokenIssuanceResponse to a JSON object
+     *
+     * @param [out] jv The JSON object to convert to
+     * @param issuance The MPTokenIssuance response to convert
+     */
+    friend void
+    tag_invoke(boost::json::value_from_tag, boost::json::value& jv, MPTokenIssuanceResponse const& issuance);
+};
+
+}  // namespace rpc
--- a/src/rpc/handlers/AccountMPTokens.cpp
+++ b/src/rpc/handlers/AccountMPTokens.cpp
@@ -0,0 +1,191 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include "rpc/handlers/AccountMPTokens.hpp"
+
+#include "rpc/Errors.hpp"
+#include "rpc/JS.hpp"
+#include "rpc/RPCHelpers.hpp"
+#include "rpc/common/Types.hpp"
+#include "util/Assert.hpp"
+#include "util/JsonUtils.hpp"
+
+#include <boost/json/conversion.hpp>
+#include <boost/json/object.hpp>
+#include <boost/json/value.hpp>
+#include <boost/json/value_to.hpp>
+#include <xrpl/basics/strHex.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/LedgerHeader.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/UintTypes.h>
+#include <xrpl/protocol/jss.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace rpc {
+
+void
+AccountMPTokensHandler::addMPToken(std::vector<MPTokenResponse>& mpts, ripple::SLE const& sle)
+{
+    MPTokenResponse token{};
+    auto const flags = sle.getFieldU32(ripple::sfFlags);
+
+    token.account = ripple::to_string(sle.getAccountID(ripple::sfAccount));
+    token.MPTokenIssuanceID = ripple::strHex(sle.getFieldH192(ripple::sfMPTokenIssuanceID));
+    token.MPTAmount = sle.getFieldU64(ripple::sfMPTAmount);
+
+    if (sle.isFieldPresent(ripple::sfLockedAmount))
+        token.lockedAmount = sle.getFieldU64(ripple::sfLockedAmount);
+
+    auto const setFlag = [&](std::optional<bool>& field, std::uint32_t mask) {
+        if ((flags & mask) != 0u)
+            field = true;
+    };
+
+    setFlag(token.mptLocked, ripple::lsfMPTLocked);
+    setFlag(token.mptAuthorized, ripple::lsfMPTAuthorized);
+
+    mpts.push_back(token);
+}
+
+AccountMPTokensHandler::Result
+AccountMPTokensHandler::process(AccountMPTokensHandler::Input const& input, Context const& ctx) const
+{
+    auto const range = sharedPtrBackend_->fetchLedgerRange();
+    ASSERT(range.has_value(), "AccountMPTokens' ledger range must be available");
+    auto const expectedLgrInfo = getLedgerHeaderFromHashOrSeq(
+        *sharedPtrBackend_, ctx.yield, input.ledgerHash, input.ledgerIndex, range->maxSequence
+    );
+
+    if (!expectedLgrInfo.has_value())
+        return Error{expectedLgrInfo.error()};
+
+    auto const& lgrInfo = expectedLgrInfo.value();
+    auto const accountID = accountFromStringStrict(input.account);
+    auto const accountLedgerObject =
+        sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield);
+
+    if (not accountLedgerObject.has_value())
+        return Error{Status{RippledError::rpcACT_NOT_FOUND}};
+
+    Output response;
+    response.mpts.reserve(input.limit);
+
+    auto const addToResponse = [&](ripple::SLE const& sle) {
+        if (sle.getType() == ripple::ltMPTOKEN) {
+            addMPToken(response.mpts, sle);
+        }
+    };
+
+    auto const expectedNext = traverseOwnedNodes(
+        *sharedPtrBackend_, *accountID, lgrInfo.seq, input.limit, input.marker, ctx.yield, addToResponse
+    );
+
+    if (!expectedNext.has_value())
+        return Error{expectedNext.error()};
+
+    auto const& nextMarker = expectedNext.value();
+
+    response.account = input.account;
+    response.limit = input.limit;
+
+    response.ledgerHash = ripple::strHex(lgrInfo.hash);
+    response.ledgerIndex = lgrInfo.seq;
+
+    if (nextMarker.isNonZero())
+        response.marker = nextMarker.toString();
+
+    return response;
+}
+
+AccountMPTokensHandler::Input
+tag_invoke(boost::json::value_to_tag<AccountMPTokensHandler::Input>, boost::json::value const& jv)
+{
+    AccountMPTokensHandler::Input input{};
+    auto const& jsonObject = jv.as_object();
+
+    input.account = boost::json::value_to<std::string>(jv.at(JS(account)));
+
+    if (jsonObject.contains(JS(limit)))
+        input.limit = util::integralValueAs<uint32_t>(jv.at(JS(limit)));
+    if (jsonObject.contains(JS(marker)))
+        input.marker = boost::json::value_to<std::string>(jv.at(JS(marker)));
+    if (jsonObject.contains(JS(ledger_hash)))
+        input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
+    if (jsonObject.contains(JS(ledger_index))) {
+        if (!jv.at(JS(ledger_index)).is_string()) {
+            input.ledgerIndex = util::integralValueAs<uint32_t>(jv.at(JS(ledger_index)));
+        } else if (boost::json::value_to<std::string>(jv.at(JS(ledger_index))) != "validated") {
+            input.ledgerIndex = std::stoi(boost::json::value_to<std::string>(jv.at(JS(ledger_index))));
+        }
+    }
+
+    return input;
+}
+
+void
+tag_invoke(boost::json::value_from_tag, boost::json::value& jv, AccountMPTokensHandler::Output const& output)
+{
+    auto obj = boost::json::object{
+        {JS(account), output.account},
+        {JS(ledger_hash), output.ledgerHash},
+        {JS(ledger_index), output.ledgerIndex},
+        {JS(validated), output.validated},
+        {JS(limit), output.limit},
+        {"mptokens", boost::json::value_from(output.mpts)},
+    };
+
+    if (output.marker.has_value())
+        obj[JS(marker)] = *output.marker;
+
+    jv = std::move(obj);
+}
+
+void
+tag_invoke(boost::json::value_from_tag, boost::json::value& jv, AccountMPTokensHandler::MPTokenResponse const& mptoken)
+{
+    auto obj = boost::json::object{
+        {JS(account), mptoken.account},
+        {JS(mpt_issuance_id), mptoken.MPTokenIssuanceID},
+        {JS(mpt_amount), mptoken.MPTAmount},
+    };
+
+    auto const setIfPresent = [&](boost::json::string_view field, auto const& value) {
+        if (value.has_value()) {
+            obj[field] = *value;
+        }
+    };
+
+    setIfPresent("locked_amount", mptoken.lockedAmount);
+    setIfPresent("mpt_locked", mptoken.mptLocked);
+    setIfPresent("mpt_authorized", mptoken.mptAuthorized);
+
+    jv = std::move(obj);
+}
+
+}  // namespace rpc
--- a/src/rpc/handlers/AccountMPTokens.hpp
+++ b/src/rpc/handlers/AccountMPTokens.hpp
@@ -0,0 +1,178 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "data/BackendInterface.hpp"
+#include "rpc/Errors.hpp"
+#include "rpc/JS.hpp"
+#include "rpc/common/Checkers.hpp"
+#include "rpc/common/MetaProcessors.hpp"
+#include "rpc/common/Modifiers.hpp"
+#include "rpc/common/Specs.hpp"
+#include "rpc/common/Types.hpp"
+#include "rpc/common/Validators.hpp"
+
+#include <boost/json/conversion.hpp>
+#include <boost/json/value.hpp>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/ErrorCodes.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/jss.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace rpc {
+
+/**
+ * @brief The account_mptokens method returns information about the MPTokens the account currently holds.
+ */
+class AccountMPTokensHandler {
+    // dependencies
+    std::shared_ptr<BackendInterface> sharedPtrBackend_;
+
+public:
+    static constexpr auto kLIMIT_MIN = 10;
+    static constexpr auto kLIMIT_MAX = 400;
+    static constexpr auto kLIMIT_DEFAULT = 200;
+
+    /**
+     * @brief A struct to hold data for one MPToken response.
+     */
+    struct MPTokenResponse {
+        std::string account;
+        std::string MPTokenIssuanceID;
+        uint64_t MPTAmount{};
+        std::optional<uint64_t> lockedAmount;
+
+        std::optional<bool> mptLocked;
+        std::optional<bool> mptAuthorized;
+    };
+
+    /**
+     * @brief A struct to hold the output data of the command.
+     */
+    struct Output {
+        std::string account;
+        std::vector<MPTokenResponse> mpts;
+        std::string ledgerHash;
+        uint32_t ledgerIndex{};
+        bool validated = true;
+        std::optional<std::string> marker;
+        uint32_t limit{};
+    };
+
+    /**
+     * @brief A struct to hold the input data for the command.
+     */
+    struct Input {
+        std::string account;
+        std::optional<std::string> ledgerHash;
+        std::optional<uint32_t> ledgerIndex;
+        uint32_t limit = kLIMIT_DEFAULT;
+        std::optional<std::string> marker;
+    };
+
+    using Result = HandlerReturnType<Output>;
+
+    /**
+     * @brief Construct a new AccountMPTokensHandler object.
+     *
+     * @param sharedPtrBackend The backend to use.
+     */
+    AccountMPTokensHandler(std::shared_ptr<BackendInterface> sharedPtrBackend)
+        : sharedPtrBackend_(std::move(sharedPtrBackend))
+    {
+    }
+
+    /**
+     * @brief Returns the API specification for the command.
+     *
+     * @param apiVersion The API version to return the spec for.
+     * @return The spec for the given API version.
+     */
+    static RpcSpecConstRef
+    spec([[maybe_unused]] uint32_t apiVersion)
+    {
+        static auto const kRPC_SPEC = RpcSpec{
+            {JS(account),
+             validation::Required{},
+             meta::WithCustomError{
+                 validation::CustomValidators::accountValidator, Status(RippledError::rpcACT_MALFORMED)
+             }},
+            {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator},
+            {JS(limit),
+             validation::Type<uint32_t>{},
+             validation::Min(1u),
+             modifiers::Clamp<int32_t>{kLIMIT_MIN, kLIMIT_MAX}},
+            {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator},
+            {JS(marker), validation::CustomValidators::accountMarkerValidator},
+            {JS(ledger), check::Deprecated{}},
+        };
+
+        return kRPC_SPEC;
+    }
+
+    /**
+     * @brief Process the AccountMPTokens command.
+     *
+     * @param input The input data for the command.
+     * @param ctx The context of the request.
+     * @return The result of the operation.
+     */
+    Result
+    process(Input const& input, Context const& ctx) const;
+
+private:
+    static void
+    addMPToken(std::vector<MPTokenResponse>& mpts, ripple::SLE const& sle);
+
+private:
+    /**
+     * @brief Convert the Output to a JSON object
+     *
+     * @param [out] jv The JSON object to convert to
+     * @param output The output to convert
+     */
+    friend void
+    tag_invoke(boost::json::value_from_tag, boost::json::value& jv, Output const& output);
+
+    /**
+     * @brief Convert a JSON object to Input type
+     *
+     * @param jv The JSON object to convert
+     * @return Input parsed from the JSON object
+     */
+    friend Input
+    tag_invoke(boost::json::value_to_tag<Input>, boost::json::value const& jv);
+
+    /**
+     * @brief Convert the MPTokenResponse to a JSON object
+     *
+     * @param [out] jv The JSON object to convert to
+     * @param mptoken The MPToken response to convert
+     */
+    friend void
+    tag_invoke(boost::json::value_from_tag, boost::json::value& jv, MPTokenResponse const& mptoken);
+};
+
+}  // namespace rpc
--- a/tests/common/util/TestObject.cpp
+++ b/tests/common/util/TestObject.cpp
@@ -1442,38 +1442,69 @@ createLptCurrency(std::string_view assetCurrency, std::string_view asset2Currenc
 }

 ripple::STObject
-createMptIssuanceObject(std::string_view accountId, std::uint32_t seq, std::string_view metadata)
+createMptIssuanceObject(
+    std::string_view accountId,
+    std::uint32_t seq,
+    std::optional<std::string_view> metadata,
+    std::uint32_t flags,
+    std::uint64_t outstandingAmount,
+    std::optional<std::uint16_t> transferFee,
+    std::optional<std::uint8_t> assetScale,
+    std::optional<std::uint64_t> maxAmount,
+    std::optional<std::uint64_t> lockedAmount,
+    std::optional<std::string_view> domainId
+)
 {
    ripple::STObject mptIssuance(ripple::sfLedgerEntry);
    mptIssuance.setAccountID(ripple::sfIssuer, getAccountIdWithString(accountId));
    mptIssuance.setFieldU16(ripple::sfLedgerEntryType, ripple::ltMPTOKEN_ISSUANCE);
-    mptIssuance.setFieldU32(ripple::sfFlags, 0);
    mptIssuance.setFieldU32(ripple::sfSequence, seq);
    mptIssuance.setFieldU64(ripple::sfOwnerNode, 0);
    mptIssuance.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{});
+    mptIssuance.setFieldU32(ripple::sfFlags, flags);
    mptIssuance.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0);
-    mptIssuance.setFieldU64(ripple::sfMaximumAmount, 0);
-    mptIssuance.setFieldU64(ripple::sfOutstandingAmount, 0);
-    ripple::Slice const sliceMetadata(metadata.data(), metadata.size());
-    mptIssuance.setFieldVL(ripple::sfMPTokenMetadata, sliceMetadata);
+    mptIssuance.setFieldU64(ripple::sfOutstandingAmount, outstandingAmount);
+
+    if (transferFee.has_value())
+        mptIssuance.setFieldU16(ripple::sfTransferFee, *transferFee);
+    if (assetScale.has_value())
+        mptIssuance.setFieldU8(ripple::sfAssetScale, *assetScale);
+    if (maxAmount.has_value())
+        mptIssuance.setFieldU64(ripple::sfMaximumAmount, *maxAmount);
+    if (lockedAmount.has_value())
+        mptIssuance.setFieldU64(ripple::sfLockedAmount, *lockedAmount);
+    if (metadata.has_value()) {
+        ripple::Slice const sliceMetadata(metadata->data(), metadata->size());
+        mptIssuance.setFieldVL(ripple::sfMPTokenMetadata, sliceMetadata);
+    }
+    if (domainId.has_value())
+        mptIssuance.setFieldH256(ripple::sfDomainID, ripple::uint256{*domainId});

    return mptIssuance;
 }

 ripple::STObject
-createMpTokenObject(std::string_view accountId, ripple::uint192 issuanceID, std::uint64_t mptAmount)
+createMpTokenObject(
+    std::string_view accountId,
+    ripple::uint192 issuanceID,
+    std::uint64_t mptAmount,
+    std::uint32_t flags,
+    std::optional<uint64_t> lockedAmount
+)
 {
    ripple::STObject mptoken(ripple::sfLedgerEntry);
    mptoken.setAccountID(ripple::sfAccount, getAccountIdWithString(accountId));
    mptoken[ripple::sfMPTokenIssuanceID] = issuanceID;
    mptoken.setFieldU16(ripple::sfLedgerEntryType, ripple::ltMPTOKEN);
-    mptoken.setFieldU32(ripple::sfFlags, 0);
+    mptoken.setFieldU32(ripple::sfFlags, flags);
    mptoken.setFieldU64(ripple::sfOwnerNode, 0);
    mptoken.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{});
    mptoken.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0);

    if (mptAmount != 0u)
        mptoken.setFieldU64(ripple::sfMPTAmount, mptAmount);
+    if (lockedAmount.has_value())
+        mptoken.setFieldU64(ripple::sfLockedAmount, *lockedAmount);

    return mptoken;
 }
--- a/tests/common/util/TestObject.hpp
+++ b/tests/common/util/TestObject.hpp
@@ -451,10 +451,27 @@ createDidObject(std::string_view accountId, std::string_view didDoc, std::string
 createLptCurrency(std::string_view assetCurrency, std::string_view asset2Currency);

 [[nodiscard]] ripple::STObject
-createMptIssuanceObject(std::string_view accountId, std::uint32_t seq, std::string_view metadata);
+createMptIssuanceObject(
+    std::string_view accountId,
+    std::uint32_t seq,
+    std::optional<std::string_view> metadata = std::nullopt,
+    std::uint32_t flags = 0,
+    std::uint64_t outstandingAmount = 0,
+    std::optional<std::uint16_t> transferFee = std::nullopt,
+    std::optional<std::uint8_t> assetScale = std::nullopt,
+    std::optional<std::uint64_t> maxAmount = std::nullopt,
+    std::optional<std::uint64_t> lockedAmount = std::nullopt,
+    std::optional<std::string_view> domainId = std::nullopt
+);

 [[nodiscard]] ripple::STObject
-createMpTokenObject(std::string_view accountId, ripple::uint192 issuanceID, std::uint64_t mptAmount = 1);
+createMpTokenObject(
+    std::string_view accountId,
+    ripple::uint192 issuanceID,
+    std::uint64_t mptAmount = 1,
+    std::uint32_t flags = 0,
+    std::optional<uint64_t> lockedAmount = std::nullopt
+);

 [[nodiscard]] ripple::STObject
 createMPTIssuanceCreateTx(std::string_view accountId, uint32_t fee, uint32_t seq);
--- a/tests/unit/CMakeLists.txt
+++ b/tests/unit/CMakeLists.txt
@@ -100,6 +100,8 @@ target_sources(
          rpc/handlers/AccountCurrenciesTests.cpp
          rpc/handlers/AccountInfoTests.cpp
          rpc/handlers/AccountLinesTests.cpp
+          rpc/handlers/AccountMPTokenIssuancesTests.cpp
+          rpc/handlers/AccountMPTokensTests.cpp
          rpc/handlers/AccountNFTsTests.cpp
          rpc/handlers/AccountObjectsTests.cpp
          rpc/handlers/AccountOffersTests.cpp
--- a/tests/unit/etlng/GrpcSourceTests.cpp
+++ b/tests/unit/etlng/GrpcSourceTests.cpp
@@ -374,10 +374,12 @@ TEST_F(GrpcSourceNgTests, DeadlineIsHandledCorrectly)
    auto grpcSource =
        std::make_unique<etlng::impl::GrpcSource>("localhost", std::to_string(getXRPLMockPort()), kDEADLINE);

+    // Note: this may not be called at all if gRPC cancels before it gets a chance to call the stub
    EXPECT_CALL(mockXrpLedgerAPIService, GetLedger)
-        .WillOnce([&](grpc::ServerContext*,
-                      org::xrpl::rpc::v1::GetLedgerRequest const*,
-                      org::xrpl::rpc::v1::GetLedgerResponse*) {
+        .Times(testing::AtMost(1))
+        .WillRepeatedly([&](grpc::ServerContext*,
+                            org::xrpl::rpc::v1::GetLedgerRequest const*,
+                            org::xrpl::rpc::v1::GetLedgerResponse*) {
            // wait for main thread to discard us and fail the test if unsuccessful within expected timeframe
            [&] { ASSERT_TRUE(sem.try_acquire_for(std::chrono::milliseconds{50})); }();
            return grpc::Status{};
--- a/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp
+++ b/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp
@@ -0,0 +1,830 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include "data/Types.hpp"
+#include "rpc/Errors.hpp"
+#include "rpc/common/AnyHandler.hpp"
+#include "rpc/common/Types.hpp"
+#include "rpc/handlers/AccountMPTokenIssuances.hpp"
+#include "util/HandlerBaseTestFixture.hpp"
+#include "util/NameGenerator.hpp"
+#include "util/TestObject.hpp"
+
+#include <boost/json/parse.hpp>
+#include <boost/json/value.hpp>
+#include <boost/json/value_to.hpp>
+#include <fmt/format.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/LedgerHeader.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STObject.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+using namespace rpc;
+using namespace data;
+namespace json = boost::json;
+using namespace testing;
+
+namespace {
+
+constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
+constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
+constexpr auto kISSUANCE_INDEX1 = "A6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321";
+constexpr auto kISSUANCE_INDEX2 = "B6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322";
+
+// unique values for issuance1
+constexpr uint64_t kISSUANCE1_MAX_AMOUNT = 10000;
+constexpr uint64_t kISSUANCE1_OUTSTANDING_AMOUNT = 5000;
+constexpr uint8_t kISSUANCE1_ASSET_SCALE = 2;
+
+// unique values for issuance2
+constexpr uint64_t kISSUANCE2_MAX_AMOUNT = 20000;
+constexpr uint64_t kISSUANCE2_OUTSTANDING_AMOUNT = 800;
+constexpr uint64_t kISSUANCE2_LOCKED_AMOUNT = 100;
+constexpr uint16_t kISSUANCE2_TRANSFER_FEE = 5;
+constexpr auto kISSUANCE2_METADATA = "test-meta";
+constexpr auto kISSUANCE2_METADATA_HEX = "746573742D6D657461";
+constexpr auto kISSUANCE2_DOMAIN_ID_HEX = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321";
+
+// define expected JSON for mpt issuances
+auto const kISSUANCE_OUT1 = fmt::format(
+    R"JSON({{
+        "issuer": "{}",
+        "sequence": 1,
+        "maximum_amount": {},
+        "outstanding_amount": {},
+        "asset_scale": {},
+        "mpt_can_escrow": true,
+        "mpt_can_trade": true,
+        "mpt_require_auth": true,
+        "mpt_can_transfer": true
+    }})JSON",
+    kACCOUNT,
+    kISSUANCE1_MAX_AMOUNT,
+    kISSUANCE1_OUTSTANDING_AMOUNT,
+    kISSUANCE1_ASSET_SCALE
+);
+
+auto const kISSUANCE_OUT2 = fmt::format(
+    R"JSON({{
+        "issuer": "{}",
+        "sequence": 2,
+        "maximum_amount": {},
+        "outstanding_amount": {},
+        "locked_amount": {},
+        "transfer_fee": {},
+        "mptoken_metadata": "{}",
+        "domain_id": "{}",
+        "mpt_can_lock": true,
+        "mpt_locked": true,
+        "mpt_can_clawback": true
+    }})JSON",
+    kACCOUNT,
+    kISSUANCE2_MAX_AMOUNT,
+    kISSUANCE2_OUTSTANDING_AMOUNT,
+    kISSUANCE2_LOCKED_AMOUNT,
+    kISSUANCE2_TRANSFER_FEE,
+    kISSUANCE2_METADATA_HEX,
+    kISSUANCE2_DOMAIN_ID_HEX
+);
+
+}  // namespace
+
+struct RPCAccountMPTokenIssuancesHandlerTest : HandlerBaseTest {
+    RPCAccountMPTokenIssuancesHandlerTest()
+    {
+        backend_->setRange(10, 30);
+    }
+};
+
+struct AccountMPTokenIssuancesParamTestCaseBundle {
+    std::string testName;
+    std::string testJson;
+    std::string expectedError;
+    std::string expectedErrorMessage;
+};
+
+struct AccountMPTokenIssuancesParameterTest : RPCAccountMPTokenIssuancesHandlerTest,
+                                              WithParamInterface<AccountMPTokenIssuancesParamTestCaseBundle> {};
+
+// generate values for invalid params test
+static auto
+generateTestValuesForInvalidParamsTest()
+{
+    return std::vector<AccountMPTokenIssuancesParamTestCaseBundle>{
+        {"NonHexLedgerHash",
+         fmt::format(R"JSON({{ "account": "{}", "ledger_hash": "xxx" }})JSON", kACCOUNT),
+         "invalidParams",
+         "ledger_hashMalformed"},
+        {"NonStringLedgerHash",
+         fmt::format(R"JSON({{ "account": "{}", "ledger_hash": 123 }})JSON", kACCOUNT),
+         "invalidParams",
+         "ledger_hashNotString"},
+        {"InvalidLedgerIndexString",
+         fmt::format(R"JSON({{ "account": "{}", "ledger_index": "notvalidated" }})JSON", kACCOUNT),
+         "invalidParams",
+         "ledgerIndexMalformed"},
+        {"MarkerNotString",
+         fmt::format(R"JSON({{ "account": "{}", "marker": 9 }})JSON", kACCOUNT),
+         "invalidParams",
+         "markerNotString"},
+        {"InvalidMarkerContent",
+         fmt::format(R"JSON({{ "account": "{}", "marker": "123invalid" }})JSON", kACCOUNT),
+         "invalidParams",
+         "Malformed cursor."},
+        {"AccountMissing", R"JSON({ "limit": 10 })JSON", "invalidParams", "Required field 'account' missing"},
+        {"AccountNotString", R"JSON({ "account": 123 })JSON", "actMalformed", "Account malformed."},
+        {"AccountMalformed",
+         R"JSON({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp" })JSON",
+         "actMalformed",
+         "Account malformed."},
+        {"LimitNotInteger",
+         fmt::format(R"JSON({{ "account": "{}", "limit": "t" }})JSON", kACCOUNT),
+         "invalidParams",
+         "Invalid parameters."},
+        {"LimitNegative",
+         fmt::format(R"JSON({{ "account": "{}", "limit": -1 }})JSON", kACCOUNT),
+         "invalidParams",
+         "Invalid parameters."},
+        {"LimitZero",
+         fmt::format(R"JSON({{ "account": "{}", "limit": 0 }})JSON", kACCOUNT),
+         "invalidParams",
+         "Invalid parameters."},
+        {"LimitTypeInvalid",
+         fmt::format(R"JSON({{ "account": "{}", "limit": true }})JSON", kACCOUNT),
+         "invalidParams",
+         "Invalid parameters."}
+    };
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    RPCAccountMPTokenIssuancesInvalidParamsGroup,
+    AccountMPTokenIssuancesParameterTest,
+    ValuesIn(generateTestValuesForInvalidParamsTest()),
+    tests::util::kNAME_GENERATOR
+);
+
+// test invalid params bundle
+TEST_P(AccountMPTokenIssuancesParameterTest, InvalidParams)
+{
+    auto const testBundle = GetParam();
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{backend_}};
+        auto const req = json::parse(testBundle.testJson);
+        auto const output = handler.process(req, Context{yield});
+        ASSERT_FALSE(output);
+
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), testBundle.expectedError);
+        EXPECT_EQ(err.at("error_message").as_string(), testBundle.expectedErrorMessage);
+    });
+}
+
+// ledger not found via hash
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerHash)
+{
+    // mock fetchLedgerByHash return empty
+    EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _))
+        .WillOnce(Return(std::optional<ripple::LedgerHeader>{}));
+
+    auto const input = json::parse(
+        fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_hash": "{}"
+            }})JSON",
+            kACCOUNT,
+            kLEDGER_HASH
+        )
+    );
+    runSpawn([&, this](boost::asio::yield_context yield) {
+        auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{backend_}};
+        auto const output = handler.process(input, Context{.yield = std::ref(yield)});
+        ASSERT_FALSE(output);
+
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+// ledger not found via string index
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerStringIndex)
+{
+    // mock fetchLedgerBySequence return empty
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional<ripple::LedgerHeader>{}));
+
+    auto const input = json::parse(
+        fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_index": "4"
+            }})JSON",
+            kACCOUNT
+        )
+    );
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_FALSE(output);
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+// ledger not found via int index
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistLedgerViaLedgerIntIndex)
+{
+    // mock fetchLedgerBySequence return empty
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional<ripple::LedgerHeader>{}));
+
+    auto const input = json::parse(
+        fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_index": 4
+            }})JSON",
+            kACCOUNT
+        )
+    );
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_FALSE(output);
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+// ledger not found via hash (seq > max)
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByHash)
+{
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31);
+    EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader));
+    auto const input = json::parse(
+        fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_hash": "{}"
+            }})JSON",
+            kACCOUNT,
+            kLEDGER_HASH
+        )
+    );
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_FALSE(output);
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+// ledger not found via index (seq > max)
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LedgerSeqOutOfRangeByIndex)
+{
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(0);
+    auto const input = json::parse(
+        fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_index": "31"
+            }})JSON",
+            kACCOUNT
+        )
+    );
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_FALSE(output);
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+// account not exist
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, NonExistAccount)
+{
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader));
+    // fetch account object return empty
+    EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(std::optional<Blob>{}));
+
+    auto const input = json::parse(
+        fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_hash": "{}"
+            }})JSON",
+            kACCOUNT,
+            kLEDGER_HASH
+        )
+    );
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_FALSE(output);
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), "actNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "Account not found.");
+    });
+}
+
+// fetch mptoken issuances via account successfully
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, DefaultParameters)
+{
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader));
+
+    // return non-empty account
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto owneDirKk = ripple::keylet::ownerDir(account).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+
+    // return two mptoken issuance objects
+    ripple::STObject const ownerDir = createOwnerDirLedgerObject(
+        {ripple::uint256{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1
+    );
+    ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData()));
+
+    // mocking mptoken issuance ledger objects
+    std::vector<Blob> bbs;
+    auto const issuance1 = createMptIssuanceObject(
+        kACCOUNT,
+        1,
+        std::nullopt,
+        ripple::lsfMPTCanTrade | ripple::lsfMPTRequireAuth | ripple::lsfMPTCanTransfer | ripple::lsfMPTCanEscrow,
+        kISSUANCE1_OUTSTANDING_AMOUNT,
+        std::nullopt,
+        kISSUANCE1_ASSET_SCALE,
+        kISSUANCE1_MAX_AMOUNT
+    );
+
+    auto const issuance2 = createMptIssuanceObject(
+        kACCOUNT,
+        2,
+        kISSUANCE2_METADATA,
+        ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback,
+        kISSUANCE2_OUTSTANDING_AMOUNT,
+        kISSUANCE2_TRANSFER_FEE,
+        std::nullopt,
+        kISSUANCE2_MAX_AMOUNT,
+        kISSUANCE2_LOCKED_AMOUNT,
+        kISSUANCE2_DOMAIN_ID_HEX
+    );
+
+    bbs.push_back(issuance1.getSerializer().peekData());
+    bbs.push_back(issuance2.getSerializer().peekData());
+    EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs));
+
+    runSpawn([this](auto yield) {
+        auto const expected = fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_hash": "{}",
+                "ledger_index": 30,
+                "validated": true,
+                "limit": {},
+                "mpt_issuances": [
+                    {},
+                    {}
+                ]
+            }})JSON",
+            kACCOUNT,
+            kLEDGER_HASH,
+            AccountMPTokenIssuancesHandler::kLIMIT_DEFAULT,
+            kISSUANCE_OUT1,
+            kISSUANCE_OUT2
+        );
+        auto const input = json::parse(fmt::format(R"JSON({{"account": "{}"}})JSON", kACCOUNT));
+        auto handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}};
+
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ(json::parse(expected), *output.result);
+    });
+}
+
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, UseLimit)
+{
+    constexpr int limit = 20;
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto owneDirKk = ripple::keylet::ownerDir(account).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+
+    std::vector<ripple::uint256> indexes;
+    std::vector<Blob> bbs;
+
+    for (int i = 0; i < 50; ++i) {
+        indexes.emplace_back(ripple::uint256{kISSUANCE_INDEX1});
+        auto const issuance = createMptIssuanceObject(kACCOUNT, i);
+        bbs.push_back(issuance.getSerializer().peekData());
+    }
+
+    ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1);
+    ownerDir.setFieldU64(ripple::sfIndexNext, 99);
+    ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData()));
+    EXPECT_CALL(*backend_, doFetchLedgerObject).Times(7);
+
+    ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs));
+    EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(3);
+
+    runSpawn([this, limit](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {}
+                }})JSON",
+                kACCOUNT,
+                limit
+            )
+        );
+
+        auto handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+
+        auto const resultJson = (*output.result).as_object();
+        EXPECT_EQ(resultJson.at("mpt_issuances").as_array().size(), limit);
+        ASSERT_TRUE(resultJson.contains("marker"));
+        EXPECT_THAT(boost::json::value_to<std::string>(resultJson.at("marker")), EndsWith(",0"));
+    });
+
+    runSpawn([this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{backend_}};
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {}
+                }})JSON",
+                kACCOUNT,
+                AccountMPTokenIssuancesHandler::kLIMIT_MIN - 1
+            )
+        );
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ((*output.result).as_object().at("limit").as_uint64(), AccountMPTokenIssuancesHandler::kLIMIT_MIN);
+    });
+
+    runSpawn([this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokenIssuancesHandler{backend_}};
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {}
+                }})JSON",
+                kACCOUNT,
+                AccountMPTokenIssuancesHandler::kLIMIT_MAX + 1
+            )
+        );
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ((*output.result).as_object().at("limit").as_uint64(), AccountMPTokenIssuancesHandler::kLIMIT_MAX);
+    });
+}
+
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerOutput)
+{
+    constexpr auto kNEXT_PAGE = 99;
+    constexpr auto kLIMIT = 15;
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto ownerDirKk = ripple::keylet::ownerDir(account).key;
+    auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+    EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3);
+
+    std::vector<ripple::uint256> indexes;
+    for (int i = 0; i < 10; ++i) {
+        indexes.emplace_back(kISSUANCE_INDEX1);
+    }
+
+    std::vector<Blob> bbs;
+    for (int i = 0; i < kLIMIT; ++i) {
+        bbs.push_back(createMptIssuanceObject(kACCOUNT, i).getSerializer().peekData());
+    }
+    EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs));
+
+    // mock the first directory page
+    ripple::STObject ownerDir1 = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1);
+    ownerDir1.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE);
+    ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _))
+        .WillByDefault(Return(ownerDir1.getSerializer().peekData()));
+
+    // mock the second directory page
+    ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX2);
+    ownerDir2.setFieldU64(ripple::sfIndexNext, 0);
+    ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, _, _))
+        .WillByDefault(Return(ownerDir2.getSerializer().peekData()));
+
+    runSpawn([this, kLIMIT, kNEXT_PAGE](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {}
+                }})JSON",
+                kACCOUNT,
+                kLIMIT
+            )
+        );
+        auto handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        auto const& resultJson = (*output.result).as_object();
+        EXPECT_EQ(
+            boost::json::value_to<std::string>(resultJson.at("marker")),
+            fmt::format("{},{}", kISSUANCE_INDEX1, kNEXT_PAGE)
+        );
+        EXPECT_EQ(resultJson.at("mpt_issuances").as_array().size(), kLIMIT);
+    });
+}
+
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MarkerInput)
+{
+    constexpr auto kNEXT_PAGE = 99;
+    constexpr auto kLIMIT = 15;
+
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+    EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3);
+
+    std::vector<Blob> bbs;
+    std::vector<ripple::uint256> indexes;
+    for (int i = 0; i < kLIMIT; ++i) {
+        indexes.emplace_back(kISSUANCE_INDEX1);
+        bbs.push_back(createMptIssuanceObject(kACCOUNT, i).getSerializer().peekData());
+    }
+
+    ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kISSUANCE_INDEX1);
+    ownerDir.setFieldU64(ripple::sfIndexNext, 0);
+    ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _))
+        .WillByDefault(Return(ownerDir.getSerializer().peekData()));
+
+    EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs));
+
+    runSpawn([this, kLIMIT, kNEXT_PAGE](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {},
+                    "marker": "{},{}"
+                }})JSON",
+                kACCOUNT,
+                kLIMIT,
+                kISSUANCE_INDEX1,
+                kNEXT_PAGE
+            )
+        );
+        auto handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+
+        auto const& resultJson = (*output.result).as_object();
+        EXPECT_TRUE(resultJson.if_contains("marker") == nullptr);
+        EXPECT_EQ(resultJson.at("mpt_issuances").as_array().size(), kLIMIT - 1);
+    });
+}
+
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitLessThanMin)
+{
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto owneDirKk = ripple::keylet::ownerDir(account).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+
+    ripple::STObject const ownerDir = createOwnerDirLedgerObject(
+        {ripple::uint256{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1
+    );
+    ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData()));
+    EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2);
+
+    std::vector<Blob> bbs;
+    auto const issuance1 = createMptIssuanceObject(
+        kACCOUNT,
+        1,
+        std::nullopt,
+        ripple::lsfMPTCanTrade | ripple::lsfMPTRequireAuth | ripple::lsfMPTCanTransfer | ripple::lsfMPTCanEscrow,
+        kISSUANCE1_OUTSTANDING_AMOUNT,
+        std::nullopt,
+        kISSUANCE1_ASSET_SCALE,
+        kISSUANCE1_MAX_AMOUNT
+    );
+
+    auto const issuance2 = createMptIssuanceObject(
+        kACCOUNT,
+        2,
+        kISSUANCE2_METADATA,
+        ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback,
+        kISSUANCE2_OUTSTANDING_AMOUNT,
+        kISSUANCE2_TRANSFER_FEE,
+        std::nullopt,
+        kISSUANCE2_MAX_AMOUNT,
+        kISSUANCE2_LOCKED_AMOUNT,
+        kISSUANCE2_DOMAIN_ID_HEX
+    );
+
+    bbs.push_back(issuance1.getSerializer().peekData());
+    bbs.push_back(issuance2.getSerializer().peekData());
+
+    EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs));
+
+    runSpawn([this](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {}
+                }})JSON",
+                kACCOUNT,
+                AccountMPTokenIssuancesHandler::kLIMIT_MIN - 1
+            )
+        );
+
+        auto const correctOutput = fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_hash": "{}",
+                "ledger_index": 30,
+                "validated": true,
+                "limit": {},
+                "mpt_issuances": [
+                    {},
+                    {}
+                ]
+            }})JSON",
+            kACCOUNT,
+            kLEDGER_HASH,
+            AccountMPTokenIssuancesHandler::kLIMIT_MIN,
+            kISSUANCE_OUT1,
+            kISSUANCE_OUT2
+        );
+
+        auto handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ(json::parse(correctOutput), *output.result);
+    });
+}
+
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, LimitMoreThanMax)
+{
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto owneDirKk = ripple::keylet::ownerDir(account).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+
+    ripple::STObject const ownerDir = createOwnerDirLedgerObject(
+        {ripple::uint256{kISSUANCE_INDEX1}, ripple::uint256{kISSUANCE_INDEX2}}, kISSUANCE_INDEX1
+    );
+    ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData()));
+    EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2);
+
+    std::vector<Blob> bbs;
+    auto const issuance1 = createMptIssuanceObject(
+        kACCOUNT,
+        1,
+        std::nullopt,
+        ripple::lsfMPTCanTrade | ripple::lsfMPTRequireAuth | ripple::lsfMPTCanTransfer | ripple::lsfMPTCanEscrow,
+        kISSUANCE1_OUTSTANDING_AMOUNT,
+        std::nullopt,
+        kISSUANCE1_ASSET_SCALE,
+        kISSUANCE1_MAX_AMOUNT
+    );
+
+    auto const issuance2 = createMptIssuanceObject(
+        kACCOUNT,
+        2,
+        kISSUANCE2_METADATA,
+        ripple::lsfMPTLocked | ripple::lsfMPTCanLock | ripple::lsfMPTCanClawback,
+        kISSUANCE2_OUTSTANDING_AMOUNT,
+        kISSUANCE2_TRANSFER_FEE,
+        std::nullopt,
+        kISSUANCE2_MAX_AMOUNT,
+        kISSUANCE2_LOCKED_AMOUNT,
+        kISSUANCE2_DOMAIN_ID_HEX
+    );
+
+    bbs.push_back(issuance1.getSerializer().peekData());
+    bbs.push_back(issuance2.getSerializer().peekData());
+
+    EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs));
+
+    runSpawn([this](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {}
+                }})JSON",
+                kACCOUNT,
+                AccountMPTokenIssuancesHandler::kLIMIT_MAX + 1
+            )
+        );
+
+        auto const correctOutput = fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_hash": "{}",
+                "ledger_index": 30,
+                "validated": true,
+                "limit": {},
+                "mpt_issuances": [
+                    {},
+                    {}
+                ]
+            }})JSON",
+            kACCOUNT,
+            kLEDGER_HASH,
+            AccountMPTokenIssuancesHandler::kLIMIT_MAX,
+            kISSUANCE_OUT1,
+            kISSUANCE_OUT2
+        );
+
+        auto handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ(json::parse(correctOutput), *output.result);
+    });
+}
+
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, EmptyResult)
+{
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto owneDirKk = ripple::keylet::ownerDir(account).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+
+    ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kISSUANCE_INDEX1);
+    ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData()));
+    EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2);
+
+    runSpawn([this](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}"
+                }})JSON",
+                kACCOUNT
+            )
+        );
+        auto handler = AnyHandler{AccountMPTokenIssuancesHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ((*output.result).as_object().at("mpt_issuances").as_array().size(), 0);
+    });
+}
--- a/tests/unit/rpc/handlers/AccountMPTokensTests.cpp
+++ b/tests/unit/rpc/handlers/AccountMPTokensTests.cpp
@@ -0,0 +1,747 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include "data/Types.hpp"
+#include "rpc/Errors.hpp"
+#include "rpc/common/AnyHandler.hpp"
+#include "rpc/common/Types.hpp"
+#include "rpc/handlers/AccountMPTokens.hpp"
+#include "util/HandlerBaseTestFixture.hpp"
+#include "util/NameGenerator.hpp"
+#include "util/TestObject.hpp"
+
+#include <boost/json/parse.hpp>
+#include <boost/json/value.hpp>
+#include <boost/json/value_to.hpp>
+#include <fmt/format.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/LedgerHeader.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STObject.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+using namespace rpc;
+using namespace data;
+namespace json = boost::json;
+using namespace testing;
+
+namespace {
+
+constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
+constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
+constexpr auto kISSUANCE_ID_HEX = "00080000B43A1A953EADDB3314A73523789947C752044C49";
+constexpr auto kTOKEN_INDEX1 = "A6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321";
+constexpr auto kTOKEN_INDEX2 = "B6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322";
+
+constexpr uint64_t kTOKEN1_AMOUNT = 500;
+constexpr uint64_t kTOKEN1_LOCKED_AMOUNT = 50;
+constexpr uint64_t kTOKEN2_AMOUNT = 250;
+
+// define expected JSON for mptokens
+auto const kTOKEN_OUT1 = fmt::format(
+    R"JSON({{
+        "account": "{}",
+        "mpt_issuance_id": "{}",
+        "mpt_amount": {},
+        "locked_amount": {},
+        "mpt_locked": true
+    }})JSON",
+    kACCOUNT,
+    kISSUANCE_ID_HEX,
+    kTOKEN1_AMOUNT,
+    kTOKEN1_LOCKED_AMOUNT
+);
+
+auto const kTOKEN_OUT2 = fmt::format(
+    R"JSON({{
+        "account": "{}",
+        "mpt_issuance_id": "{}",
+        "mpt_amount": {},
+        "mpt_authorized": true
+    }})JSON",
+    kACCOUNT,
+    kISSUANCE_ID_HEX,
+    kTOKEN2_AMOUNT
+);
+
+}  // namespace
+
+struct RPCAccountMPTokensHandlerTest : HandlerBaseTest {
+    RPCAccountMPTokensHandlerTest()
+    {
+        backend_->setRange(10, 30);
+    }
+};
+
+struct AccountMPTokensParamTestCaseBundle {
+    std::string testName;
+    std::string testJson;
+    std::string expectedError;
+    std::string expectedErrorMessage;
+};
+
+struct AccountMPTokensParameterTest : RPCAccountMPTokensHandlerTest,
+                                      WithParamInterface<AccountMPTokensParamTestCaseBundle> {};
+
+// generate values for invalid params test
+static auto
+generateTestValuesForInvalidParamsTest()
+{
+    return std::vector<AccountMPTokensParamTestCaseBundle>{
+        {"NonHexLedgerHash",
+         fmt::format(R"JSON({{ "account": "{}", "ledger_hash": "xxx" }})JSON", kACCOUNT),
+         "invalidParams",
+         "ledger_hashMalformed"},
+        {"NonStringLedgerHash",
+         fmt::format(R"JSON({{ "account": "{}", "ledger_hash": 123 }})JSON", kACCOUNT),
+         "invalidParams",
+         "ledger_hashNotString"},
+        {"InvalidLedgerIndexString",
+         fmt::format(R"JSON({{ "account": "{}", "ledger_index": "notvalidated" }})JSON", kACCOUNT),
+         "invalidParams",
+         "ledgerIndexMalformed"},
+        {"MarkerNotString",
+         fmt::format(R"JSON({{ "account": "{}", "marker": 9 }})JSON", kACCOUNT),
+         "invalidParams",
+         "markerNotString"},
+        {"InvalidMarkerContent",
+         fmt::format(R"JSON({{ "account": "{}", "marker": "123invalid" }})JSON", kACCOUNT),
+         "invalidParams",
+         "Malformed cursor."},
+        {"AccountMissing", R"JSON({ "limit": 10 })JSON", "invalidParams", "Required field 'account' missing"},
+        {"AccountNotString", R"JSON({ "account": 123 })JSON", "actMalformed", "Account malformed."},
+        {"AccountMalformed",
+         fmt::format(R"JSON({{ "account": "{}" }})JSON", "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp"),
+         "actMalformed",
+         "Account malformed."},
+        {"LimitNotInteger",
+         fmt::format(R"JSON({{ "account": "{}", "limit": "t" }})JSON", kACCOUNT),
+         "invalidParams",
+         "Invalid parameters."},
+        {"LimitNegative",
+         fmt::format(R"JSON({{ "account": "{}", "limit": -1 }})JSON", kACCOUNT),
+         "invalidParams",
+         "Invalid parameters."},
+        {"LimitZero",
+         fmt::format(R"JSON({{ "account": "{}", "limit": 0 }})JSON", kACCOUNT),
+         "invalidParams",
+         "Invalid parameters."},
+        {"LimitTypeInvalid",
+         fmt::format(R"JSON({{ "account": "{}", "limit": true }})JSON", kACCOUNT),
+         "invalidParams",
+         "Invalid parameters."}
+    };
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    RPCAccountMPTokensInvalidParamsGroup,
+    AccountMPTokensParameterTest,
+    ValuesIn(generateTestValuesForInvalidParamsTest()),
+    tests::util::kNAME_GENERATOR
+);
+
+// test invalid params bundle
+TEST_P(AccountMPTokensParameterTest, InvalidParams)
+{
+    auto const testBundle = GetParam();
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokensHandler{backend_}};
+        auto const req = json::parse(testBundle.testJson);
+        auto const output = handler.process(req, Context{yield});
+        ASSERT_FALSE(output);
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), testBundle.expectedError);
+        EXPECT_EQ(err.at("error_message").as_string(), testBundle.expectedErrorMessage);
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerHash)
+{
+    // mock fetchLedgerByHash to return empty
+    EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _))
+        .WillOnce(Return(std::optional<ripple::LedgerHeader>{}));
+
+    auto const input = json::parse(
+        fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_hash": "{}"
+            }})JSON",
+            kACCOUNT,
+            kLEDGER_HASH
+        )
+    );
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokensHandler{backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_FALSE(output);
+
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerStringIndex)
+{
+    // mock fetchLedgerBySequence to return empty
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional<ripple::LedgerHeader>{}));
+
+    auto const input = json::parse(
+        fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_index": "4"
+            }})JSON",
+            kACCOUNT
+        )
+    );
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokensHandler{backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_FALSE(output);
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, NonExistLedgerViaLedgerIntIndex)
+{
+    // mock fetchLedgerBySequence to return empty
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(std::optional<ripple::LedgerHeader>{}));
+
+    auto const input = json::parse(
+        fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_index": 4
+            }})JSON",
+            kACCOUNT
+        )
+    );
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokensHandler{backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_FALSE(output);
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByHash)
+{
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 31);
+    EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader));
+
+    auto const input = json::parse(
+        fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_hash": "{}"
+            }})JSON",
+            kACCOUNT,
+            kLEDGER_HASH
+        )
+    );
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokensHandler{backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_FALSE(output);
+
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, LedgerSeqOutOfRangeByIndex)
+{
+    // No need to check from db, call fetchLedgerBySequence 0 times
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(0);
+    auto const input = json::parse(
+        fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_index": "31"
+            }})JSON",
+            kACCOUNT
+        )
+    );
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokensHandler{backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_FALSE(output);
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, NonExistAccount)
+{
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillOnce(Return(ledgerHeader));
+    // fetch account object return empty
+    EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(Return(std::optional<Blob>{}));
+
+    auto const input = json::parse(
+        fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_hash": "{}"
+            }})JSON",
+            kACCOUNT,
+            kLEDGER_HASH
+        )
+    );
+
+    runSpawn([&, this](auto yield) {
+        auto const handler = AnyHandler{AccountMPTokensHandler{backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_FALSE(output);
+        auto const err = rpc::makeError(output.result.error());
+        EXPECT_EQ(err.at("error").as_string(), "actNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "Account not found.");
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, DefaultParameters)
+{
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto owneDirKk = ripple::keylet::ownerDir(account).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+
+    ripple::STObject const ownerDir =
+        createOwnerDirLedgerObject({ripple::uint256{kTOKEN_INDEX1}, ripple::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1);
+    ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData()));
+
+    std::vector<Blob> bbs;
+    auto const token1 = createMpTokenObject(
+        kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), kTOKEN1_AMOUNT, ripple::lsfMPTLocked, kTOKEN1_LOCKED_AMOUNT
+    );
+
+    auto const token2 = createMpTokenObject(
+        kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), kTOKEN2_AMOUNT, ripple::lsfMPTAuthorized, std::nullopt
+    );
+
+    bbs.push_back(token1.getSerializer().peekData());
+    bbs.push_back(token2.getSerializer().peekData());
+
+    EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs));
+
+    runSpawn([this](auto yield) {
+        auto const expected = fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_hash": "{}",
+                "ledger_index": 30,
+                "validated": true,
+                "limit": {},
+                "mptokens": [
+                    {},
+                    {}
+                ]
+            }})JSON",
+            kACCOUNT,
+            kLEDGER_HASH,
+            AccountMPTokensHandler::kLIMIT_DEFAULT,
+            kTOKEN_OUT1,
+            kTOKEN_OUT2
+        );
+        auto const input = json::parse(fmt::format(R"JSON({{"account": "{}"}})JSON", kACCOUNT));
+        auto handler = AnyHandler{AccountMPTokensHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ(json::parse(expected), *output.result);
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, UseLimit)
+{
+    constexpr int limit = 20;
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    ON_CALL(*backend_, fetchLedgerBySequence).WillByDefault(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto owneDirKk = ripple::keylet::ownerDir(account).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+
+    std::vector<ripple::uint256> indexes;
+    std::vector<Blob> bbs;
+
+    for (int i = 0; i < 50; ++i) {
+        indexes.emplace_back(ripple::uint256{kTOKEN_INDEX1});
+        auto const token = createMpTokenObject(kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt);
+        bbs.push_back(token.getSerializer().peekData());
+    }
+
+    ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTOKEN_INDEX1);
+    ownerDir.setFieldU64(ripple::sfIndexNext, 99);
+    ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData()));
+    EXPECT_CALL(*backend_, doFetchLedgerObject).Times(7);
+
+    ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs));
+    EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(3);
+
+    runSpawn([this, limit](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {}
+                }})JSON",
+                kACCOUNT,
+                limit
+            )
+        );
+
+        auto handler = AnyHandler{AccountMPTokensHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+
+        auto const resultJson = (*output.result).as_object();
+        EXPECT_EQ(resultJson.at("mptokens").as_array().size(), limit);
+        ASSERT_TRUE(resultJson.contains("marker"));
+        EXPECT_THAT(boost::json::value_to<std::string>(resultJson.at("marker")), EndsWith(",0"));
+    });
+
+    runSpawn([this](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {}
+                }})JSON",
+                kACCOUNT,
+                AccountMPTokensHandler::kLIMIT_MIN - 1
+            )
+        );
+
+        auto handler = AnyHandler{AccountMPTokensHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ((*output.result).as_object().at("limit").as_uint64(), AccountMPTokensHandler::kLIMIT_MIN);
+    });
+
+    runSpawn([this](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {}
+                }})JSON",
+                kACCOUNT,
+                AccountMPTokensHandler::kLIMIT_MAX + 1
+            )
+        );
+
+        auto handler = AnyHandler{AccountMPTokensHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ((*output.result).as_object().at("limit").as_uint64(), AccountMPTokensHandler::kLIMIT_MAX);
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, MarkerOutput)
+{
+    constexpr auto kNEXT_PAGE = 99;
+    constexpr auto kLIMIT = 15;
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto ownerDirKk = ripple::keylet::ownerDir(account).key;
+    auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+
+    std::vector<Blob> bbs;
+    for (int i = 0; i < kLIMIT; ++i) {
+        bbs.push_back(createMpTokenObject(kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt)
+                          .getSerializer()
+                          .peekData());
+    }
+    EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs));
+
+    std::vector<ripple::uint256> indexes1;
+    for (int i = 0; i < 10; ++i) {
+        indexes1.emplace_back(kTOKEN_INDEX1);
+    }
+    ripple::STObject ownerDir1 = createOwnerDirLedgerObject(indexes1, kTOKEN_INDEX1);
+    ownerDir1.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE);
+    ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _))
+        .WillByDefault(Return(ownerDir1.getSerializer().peekData()));
+
+    ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes1, kTOKEN_INDEX2);
+    ownerDir2.setFieldU64(ripple::sfIndexNext, 0);
+    ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, _, _))
+        .WillByDefault(Return(ownerDir2.getSerializer().peekData()));
+    EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3);
+
+    runSpawn([this, kLIMIT, kNEXT_PAGE](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {}
+                }})JSON",
+                kACCOUNT,
+                kLIMIT
+            )
+        );
+        auto handler = AnyHandler{AccountMPTokensHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        auto const& resultJson = (*output.result).as_object();
+        EXPECT_EQ(resultJson.at("mptokens").as_array().size(), kLIMIT);
+        EXPECT_EQ(
+            boost::json::value_to<std::string>(resultJson.at("marker")), fmt::format("{},{}", kTOKEN_INDEX1, kNEXT_PAGE)
+        );
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, MarkerInput)
+{
+    constexpr auto kNEXT_PAGE = 99;
+    constexpr auto kLIMIT = 15;
+
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+    auto ownerDirKk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key;
+
+    std::vector<Blob> bbs;
+    std::vector<ripple::uint256> indexes;
+    for (int i = 0; i < kLIMIT; ++i) {
+        indexes.emplace_back(kTOKEN_INDEX1);
+        bbs.push_back(createMpTokenObject(kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), i, 0, std::nullopt)
+                          .getSerializer()
+                          .peekData());
+    }
+
+    ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kTOKEN_INDEX1);
+    ownerDir.setFieldU64(ripple::sfIndexNext, 0);
+    ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, _, _))
+        .WillByDefault(Return(ownerDir.getSerializer().peekData()));
+
+    EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3);
+    EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs));
+
+    runSpawn([this, kLIMIT, kNEXT_PAGE](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {},
+                    "marker": "{},{}"
+                }})JSON",
+                kACCOUNT,
+                kLIMIT,
+                kTOKEN_INDEX1,
+                kNEXT_PAGE
+            )
+        );
+        auto handler = AnyHandler{AccountMPTokensHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        auto const& resultJson = (*output.result).as_object();
+        EXPECT_TRUE(resultJson.if_contains("marker") == nullptr);
+        EXPECT_EQ(resultJson.at("mptokens").as_array().size(), kLIMIT - 1);
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, LimitLessThanMin)
+{
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto owneDirKk = ripple::keylet::ownerDir(account).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+
+    ripple::STObject const ownerDir =
+        createOwnerDirLedgerObject({ripple::uint256{kTOKEN_INDEX1}, ripple::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1);
+    ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData()));
+    EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2);
+
+    std::vector<Blob> bbs;
+    auto const token1 = createMpTokenObject(
+        kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), kTOKEN1_AMOUNT, ripple::lsfMPTLocked, kTOKEN1_LOCKED_AMOUNT
+    );
+    bbs.push_back(token1.getSerializer().peekData());
+
+    auto const token2 = createMpTokenObject(
+        kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), kTOKEN2_AMOUNT, ripple::lsfMPTAuthorized, std::nullopt
+    );
+    bbs.push_back(token2.getSerializer().peekData());
+
+    EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs));
+
+    runSpawn([this](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {}
+                }})JSON",
+                kACCOUNT,
+                AccountMPTokensHandler::kLIMIT_MIN - 1
+            )
+        );
+
+        auto const correctOutput = fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_hash": "{}",
+                "ledger_index": 30,
+                "validated": true,
+                "limit": {},
+                "mptokens": [
+                    {},
+                    {}
+                ]
+            }})JSON",
+            kACCOUNT,
+            kLEDGER_HASH,
+            AccountMPTokensHandler::kLIMIT_MIN,
+            kTOKEN_OUT1,
+            kTOKEN_OUT2
+        );
+
+        auto handler = AnyHandler{AccountMPTokensHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ(json::parse(correctOutput), *output.result);
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, LimitMoreThanMax)
+{
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto owneDirKk = ripple::keylet::ownerDir(account).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+
+    ripple::STObject const ownerDir =
+        createOwnerDirLedgerObject({ripple::uint256{kTOKEN_INDEX1}, ripple::uint256{kTOKEN_INDEX2}}, kTOKEN_INDEX1);
+    ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData()));
+    EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2);
+
+    std::vector<Blob> bbs;
+    auto const token1 = createMpTokenObject(
+        kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), kTOKEN1_AMOUNT, ripple::lsfMPTLocked, kTOKEN1_LOCKED_AMOUNT
+    );
+    bbs.push_back(token1.getSerializer().peekData());
+
+    auto const token2 = createMpTokenObject(
+        kACCOUNT, ripple::uint192(kISSUANCE_ID_HEX), kTOKEN2_AMOUNT, ripple::lsfMPTAuthorized, std::nullopt
+    );
+    bbs.push_back(token2.getSerializer().peekData());
+
+    EXPECT_CALL(*backend_, doFetchLedgerObjects).WillOnce(Return(bbs));
+
+    runSpawn([this](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}",
+                    "limit": {}
+                }})JSON",
+                kACCOUNT,
+                AccountMPTokensHandler::kLIMIT_MAX + 1
+            )
+        );
+
+        auto const correctOutput = fmt::format(
+            R"JSON({{
+                "account": "{}",
+                "ledger_hash": "{}",
+                "ledger_index": 30,
+                "validated": true,
+                "limit": {},
+                "mptokens": [
+                    {},
+                    {}
+                ]
+            }})JSON",
+            kACCOUNT,
+            kLEDGER_HASH,
+            AccountMPTokensHandler::kLIMIT_MAX,
+            kTOKEN_OUT1,
+            kTOKEN_OUT2
+        );
+
+        auto handler = AnyHandler{AccountMPTokensHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ(json::parse(correctOutput), *output.result);
+    });
+}
+
+TEST_F(RPCAccountMPTokensHandlerTest, EmptyResult)
+{
+    auto ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
+    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader));
+
+    auto account = getAccountIdWithString(kACCOUNT);
+    auto accountKk = ripple::keylet::account(account).key;
+    auto owneDirKk = ripple::keylet::ownerDir(account).key;
+    ON_CALL(*backend_, doFetchLedgerObject(accountKk, _, _)).WillByDefault(Return(Blob{'f', 'a', 'k', 'e'}));
+
+    ripple::STObject const ownerDir = createOwnerDirLedgerObject({}, kTOKEN_INDEX1);
+    ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, _, _)).WillByDefault(Return(ownerDir.getSerializer().peekData()));
+    EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2);
+
+    runSpawn([this](auto yield) {
+        auto const input = json::parse(
+            fmt::format(
+                R"JSON({{
+                    "account": "{}"
+                }})JSON",
+                kACCOUNT
+            )
+        );
+        auto handler = AnyHandler{AccountMPTokensHandler{this->backend_}};
+        auto const output = handler.process(input, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ((*output.result).as_object().at("mptokens").as_array().size(), 0);
+    });
+}
--- a/tests/unit/rpc/handlers/AllHandlerTests.cpp
+++ b/tests/unit/rpc/handlers/AllHandlerTests.cpp
@@ -23,6 +23,8 @@
 #include "rpc/handlers/AccountCurrencies.hpp"
 #include "rpc/handlers/AccountInfo.hpp"
 #include "rpc/handlers/AccountLines.hpp"
+#include "rpc/handlers/AccountMPTokenIssuances.hpp"
+#include "rpc/handlers/AccountMPTokens.hpp"
 #include "rpc/handlers/AccountNFTs.hpp"
 #include "rpc/handlers/AccountObjects.hpp"
 #include "rpc/handlers/AccountOffers.hpp"
@@ -86,6 +88,8 @@ using AnyHandlerType = Types<
    AccountCurrenciesHandler,
    AccountInfoHandler,
    AccountLinesHandler,
+    AccountMPTokenIssuancesHandler,
+    AccountMPTokensHandler,
    AccountNFTsHandler,
    AccountObjectsHandler,
    AccountOffersHandler,
--- a/tests/unit/rpc/handlers/LedgerEntryTests.cpp
+++ b/tests/unit/rpc/handlers/LedgerEntryTests.cpp
@@ -3756,7 +3756,6 @@ TEST_F(RPCLedgerEntryTest, SyntheticMPTIssuanceID)
            "Issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
            "LedgerEntryType": "MPTokenIssuance",
            "MPTokenMetadata": "6D65746164617461",
-            "MaximumAmount": "0",
            "OutstandingAmount": "0",
            "OwnerNode": "0",
            "PreviousTxnID": "0000000000000000000000000000000000000000000000000000000000000000",
--- a/tests/unit/rpc/handlers/VaultInfoTests.cpp
+++ b/tests/unit/rpc/handlers/VaultInfoTests.cpp
@@ -309,7 +309,6 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByVaultID)
                    "Issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
                    "LedgerEntryType": "MPTokenIssuance",
                    "MPTokenMetadata": "6D65746164617461",
-                    "MaximumAmount": "0",
                    "OutstandingAmount": "0",
                    "OwnerNode": "0",
                    "PreviousTxnID": "0000000000000000000000000000000000000000000000000000000000000000",
@@ -393,7 +392,6 @@ TEST_F(RPCVaultInfoHandlerTest, ValidVaultObjectQueryByOwnerAndSeq)
                    "Issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
                    "LedgerEntryType": "MPTokenIssuance",
                    "MPTokenMetadata": "6D65746164617461",
-                    "MaximumAmount": "0",
                    "OutstandingAmount": "0",
                    "OwnerNode": "0",
                    "PreviousTxnID": "0000000000000000000000000000000000000000000000000000000000000000",
Author	SHA1	Message	Date
yinyiqian1	2f25cb60c7	Merge branch 'develop' into account_mpts	2025-10-28 11:23:32 -04:00
Ayaz Salikhov	8c8a7ff3b8	ci: Use XRPLF/get-nproc (#2727 )	2025-10-27 18:50:40 +00:00
Ayaz Salikhov	16493abd0d	ci: Better pre-commit failure message (#2720 )	2025-10-27 12:14:56 +00:00
dependabot[bot]	3dd72d94e1	ci: [DEPENDABOT] bump actions/download-artifact from 5.0.0 to 6.0.0 (#2723 ) Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-10-27 10:17:41 +00:00
dependabot[bot]	5e914abf29	ci: [DEPENDABOT] bump actions/upload-artifact from 4.6.2 to 5.0.0 in /.github/actions/code-coverage (#2725 ) Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-10-27 10:16:14 +00:00
dependabot[bot]	9603968808	ci: [DEPENDABOT] bump actions/upload-artifact from 4.6.2 to 5.0.0 (#2722 ) Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-10-27 10:15:39 +00:00
Ayaz Salikhov	0124c06a53	ci: Enable clang asan builds (#2717 )	2025-10-24 13:36:14 +01:00
Ayaz Salikhov	890279b15e	Merge branch 'develop' into account_mpts	2025-10-24 08:53:50 +01:00
yinyiqian1	022f2a44b4	resolve new comments	2025-10-23 23:55:14 -04:00
Ayaz Salikhov	1bfdd0dd89	ci: Save full logs for failed sanitized tests (#2715 )	2025-10-23 17:06:02 +01:00
Alex Kremer	f41d574204	fix: Flaky DeadlineIsHandledCorrectly (#2716 )	2025-10-23 16:33:58 +01:00
Ayaz Salikhov	d0ec60381b	ci: Use intermediate environment variables for improved security (#2713 )	2025-10-23 11:34:53 +01:00
Ayaz Salikhov	0b19a42a96	ci: Pin all GitHub actions (#2712 )	2025-10-22 16:17:15 +01:00
emrearıyürek	030f4f1b22	docs: Remove logging.md from readme (#2710 )	2025-10-22 11:36:49 +01:00
yinyiqian1	187dd4ae90	fix doxygen	2025-10-21 10:35:14 -04:00
yinyiqian1	2c3e4dec74	Merge branch 'develop' into account_mpts	2025-10-20 21:13:29 -04:00
yinyiqian1	f2a40726c7	Merge branch 'develop' into account_mpts	2025-10-17 15:48:22 -04:00
yinyiqian1	e8a64d838c	Merge branch 'develop' into account_mpts	2025-10-16 14:27:13 -04:00
yinyiqian1	c351ace6ec	Merge branch 'develop' into account_mpts	2025-10-16 12:16:16 -04:00
yinyiqian1	05dd0b3412	Merge branch 'develop' into account_mpts	2025-10-15 13:49:34 -04:00
yinyiqian1	685fab5d17	resolve comments	2025-10-15 13:18:09 -04:00
Ayaz Salikhov	79fc0b10c3	Merge branch 'develop' into account_mpts	2025-10-08 17:46:31 +01:00
yinyiqian1	676f7f0d6a	feat: Support account MPToken	2025-10-07 19:21:53 -04:00