Fix build.md wamr version (#5535)

* Sync error codes

.clang-format

@@ -1,5 +1,5 @@
 ---
-Language:        Cpp
+Language: Cpp
 AccessModifierOffset: -4
 AlignAfterOpenBracket: AlwaysBreak
 AlignConsecutiveAssignments: false
@@ -19,52 +19,52 @@ AlwaysBreakTemplateDeclarations: true
 BinPackArguments: false
 BinPackParameters: false
 BraceWrapping:
-  AfterClass:      true
+  AfterClass: true
   AfterControlStatement: true
-  AfterEnum:       false
-  AfterFunction:   true
-  AfterNamespace:  false
+  AfterEnum: false
+  AfterFunction: true
+  AfterNamespace: false
   AfterObjCDeclaration: true
-  AfterStruct:     true
-  AfterUnion:      true
-  BeforeCatch:     true
-  BeforeElse:      true
-  IndentBraces:    false
+  AfterStruct: true
+  AfterUnion: true
+  BeforeCatch: true
+  BeforeElse: true
+  IndentBraces: false
 BreakBeforeBinaryOperators: false
 BreakBeforeBraces: Custom
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializersBeforeComma: true
-ColumnLimit:     80
-CommentPragmas:  '^ IWYU pragma:'
+ColumnLimit: 80
+CommentPragmas: "^ IWYU pragma:"
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: true
 DerivePointerAlignment: false
-DisableFormat:   false
+DisableFormat: false
 ExperimentalAutoDetectBinPacking: false
-ForEachMacros:   [ Q_FOREACH,  BOOST_FOREACH ]
-IncludeBlocks:   Regroup
+ForEachMacros: [Q_FOREACH, BOOST_FOREACH]
+IncludeBlocks: Regroup
 IncludeCategories:
-  - Regex:           '^<(test)/'
-    Priority:        0
-  - Regex:           '^<(xrpld)/'
-    Priority:        1
-  - Regex:           '^<(xrpl)/'
-    Priority:        2
-  - Regex:           '^<(boost)/'
-    Priority:        3
-  - Regex:           '^.*/'
-    Priority:        4
-  - Regex:           '^.*\.h'
-    Priority:        5
-  - Regex:           '.*'
-    Priority:        6
-IncludeIsMainRegex: '$'
+  - Regex: "^<(test)/"
+    Priority: 0
+  - Regex: "^<(xrpld)/"
+    Priority: 1
+  - Regex: "^<(xrpl)/"
+    Priority: 2
+  - Regex: "^<(boost)/"
+    Priority: 3
+  - Regex: "^.*/"
+    Priority: 4
+  - Regex: '^.*\.h'
+    Priority: 5
+  - Regex: ".*"
+    Priority: 6
+IncludeIsMainRegex: "$"
 IndentCaseLabels: true
 IndentFunctionDeclarationAfterType: false
 IndentRequiresClause: true
-IndentWidth:     4
+IndentWidth: 4
 IndentWrappedFunctionNames: false
 KeepEmptyLinesAtTheStartOfBlocks: false
 MaxEmptyLinesToKeep: 1
@@ -78,20 +78,20 @@ PenaltyBreakString: 1000
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 200
 PointerAlignment: Left
-ReflowComments:  true
+ReflowComments: true
 RequiresClausePosition: OwnLine
-SortIncludes:    true
+SortIncludes: true
 SpaceAfterCStyleCast: false
 SpaceBeforeAssignmentOperators: true
 SpaceBeforeParens: ControlStatements
 SpaceInEmptyParentheses: false
 SpacesBeforeTrailingComments: 2
-SpacesInAngles:  false
+SpacesInAngles: false
 SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard:        Cpp11
-TabWidth:        8
-UseTab:          Never
-QualifierAlignment: Right
+Standard: Cpp11
+TabWidth: 8
+UseTab: Never
+QualifierAlignment: Right

.github/CODEOWNERS

@@ -1,8 +1,2 @@
 # Allow anyone to review any change by default.
 *
-
-# Require the rpc-reviewers team to review changes to the rpc code.
-include/xrpl/protocol/ @xrplf/rpc-reviewers
-src/libxrpl/protocol/ @xrplf/rpc-reviewers
-src/xrpld/rpc/ @xrplf/rpc-reviewers
-src/xrpld/app/misc/ @xrplf/rpc-reviewers

.github/actions/dependencies/action.yml

@@ -6,29 +6,37 @@ inputs:
 runs:
   using: composite
   steps:
+    - name: unlock Conan
+      shell: bash
+      run: conan remove --locks
     - name: export custom recipes
       shell: bash
       run: |
-        conan export --version 1.1.10 external/snappy
-        conan export --version 4.0.3 external/soci
+        conan config set general.revisions_enabled=1
+        conan export external/snappy snappy/1.1.10@
+        conan export external/rocksdb rocksdb/9.7.3@
+        conan export external/soci soci/4.0.3@
+        conan export external/nudb nudb/2.0.8@
+        conan export external/wamr wamr/2.3.1@
     - name: add Ripple Conan remote
-      if: env.CONAN_URL != ''
       shell: bash
       run: |
-        if conan remote list | grep -q "ripple"; then
-            conan remote remove ripple
-            echo "Removed conan remote ripple"
-        fi
-        conan remote add --index 0 ripple "${CONAN_URL}"
-        echo "Added conan remote ripple at ${CONAN_URL}"
+        conan remote list
+        conan remote remove ripple || true
+        # Do not quote the URL. An empty string will be accepted (with
+        # a non-fatal warning), but a missing argument will not.
+        conan remote add ripple ${{ env.CONAN_URL }} --insert 0
     - name: try to authenticate to Ripple Conan remote
-      if: env.CONAN_LOGIN_USERNAME_RIPPLE != '' && env.CONAN_PASSWORD_RIPPLE != ''
       id: remote
       shell: bash
       run: |
-        echo "Authenticating to ripple remote..."
-        conan remote auth ripple --force
-        conan remote list-users
+        # `conan user` implicitly uses the environment variables
+        # CONAN_LOGIN_USERNAME_<REMOTE> and CONAN_PASSWORD_<REMOTE>.
+        # https://docs.conan.io/1/reference/commands/misc/user.html#using-environment-variables
+        # https://docs.conan.io/1/reference/env_vars.html#conan-login-username-conan-login-username-remote-name
+        # https://docs.conan.io/1/reference/env_vars.html#conan-password-conan-password-remote-name
+        echo outcome=$(conan user --remote ripple --password >&2 \
+          && echo success || echo failure) | tee ${GITHUB_OUTPUT}
     - name: list missing binaries
       id: binaries
       shell: bash
@@ -43,8 +51,8 @@ runs:
         cd ${build_dir}
         conan install \
           --output-folder . \
-          --build '*' \
-          --options:host "&:tests=True" \
-          --options:host "&:xrpld=True" \
-          --settings:all build_type=${{ inputs.configuration }} \
+          --build missing \
+          --options tests=True \
+          --options xrpld=True \
+          --settings build_type=${{ inputs.configuration }} \
           ..

.github/workflows/clang-format.yml

@@ -9,25 +9,24 @@ jobs:
   check:
     if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     runs-on: ubuntu-24.04
-    container: ghcr.io/xrplf/ci/tools-rippled-clang-format
+    env:
+      CLANG_VERSION: 18
     steps:
-      # For jobs running in containers, $GITHUB_WORKSPACE and ${{ github.workspace }} might not be the
-      # same directory. The actions/checkout step is *supposed* to checkout into $GITHUB_WORKSPACE and
-      # then add it to safe.directory (see instructions at https://github.com/actions/checkout)
-      # but that's apparently not happening for some container images. We can't be sure what is actually
-      # happening, so let's pre-emptively add both directories to safe.directory. There's a
-      # Github issue opened in 2022 and not resolved in 2025 https://github.com/actions/runner/issues/2058 ¯\_(ツ)_/¯
-      - run: |
-          git config --global --add safe.directory $GITHUB_WORKSPACE
-          git config --global --add safe.directory ${{ github.workspace }}
       - uses: actions/checkout@v4
-      - name: Format first-party sources
+      - name: Install clang-format
         run: |
-          clang-format --version
-          find include src tests -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format -i {} +
+          codename=$( lsb_release --codename --short )
+          sudo tee /etc/apt/sources.list.d/llvm.list >/dev/null <<EOF
+          deb http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
+          deb-src http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
+          EOF
+          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add
+          sudo apt-get update
+          sudo apt-get install clang-format-${CLANG_VERSION}
+      - name: Format first-party sources
+        run: find include src tests -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format-${CLANG_VERSION} -i {} +
       - name: Check for differences
         id: assert
-        shell: bash
         run: |
           set -o pipefail
           git diff --exit-code | tee "clang-format.patch"
@@ -59,6 +58,6 @@ jobs:
                in your repo, commit, and push.
         run: |
           echo "${PREAMBLE}"
-          clang-format --version
+          clang-format-${CLANG_VERSION} --version
           echo "${SUGGESTION}"
           exit 1

.github/workflows/macos.yml

@@ -15,18 +15,6 @@ on:
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
-# This part of Conan configuration is specific to this workflow only; we do not want
-# to pollute conan/profiles directory with settings which might not work for others
-env:
-  CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/dev
-  CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
-  CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
-  CONAN_GLOBAL_CONF: |
-    core.download:parallel={{os.cpu_count()}}
-    core.upload:parallel={{os.cpu_count()}}
-    tools.build:jobs={{ (os.cpu_count() * 4/5) | int }}
-    tools.build:verbosity=verbose
-    tools.compilation:verbosity=verbose
 
 jobs:
 
@@ -40,22 +28,23 @@ jobs:
           - Ninja
         configuration:
           - Release
-    runs-on: [self-hosted, macOS, mac-runner-m1]
+    runs-on: [self-hosted, macOS]
     env:
       # The `build` action requires these variables.
       build_dir: .build
       NUM_PROCESSORS: 12
     steps:
       - name: checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        uses: actions/checkout@v4
       - name: install Conan
         run: |
-          brew install conan
+          brew install conan@1
+          echo '/opt/homebrew/opt/conan@1/bin' >> $GITHUB_PATH
       - name: install Ninja
         if: matrix.generator == 'Ninja'
         run: brew install ninja
       - name: install python
-        run: |
+        run: | 
           if which python > /dev/null 2>&1; then
               echo "Python executable exists"
           else
@@ -87,26 +76,14 @@ jobs:
           clang --version
       - name: configure Conan
         run : |
-          echo "${CONAN_GLOBAL_CONF}" >> $(conan config home)/global.conf
-          conan config install conan/profiles/ -tf $(conan config home)/profiles/
-          conan profile show
-      - name: export custom recipes
-        shell: bash
-        run: |
-          conan export --version 1.1.10 external/snappy
-          conan export --version 4.0.3 external/soci
-      - name: add Ripple Conan remote
-        if: env.CONAN_URL != ''
-        shell: bash
-        run: |
-          if conan remote list | grep -q "ripple"; then
-              conan remote remove ripple
-              echo "Removed conan remote ripple"
-          fi
-          conan remote add --index 0 ripple "${CONAN_URL}"
-          echo "Added conan remote ripple at ${CONAN_URL}"
+          conan profile new default --detect || true
+          conan profile update settings.compiler.cppstd=20 default
       - name: build dependencies
         uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+          CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
+          CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
         with:
           configuration: ${{ matrix.configuration }}
       - name: build

.github/workflows/nix.yml

@@ -16,19 +16,6 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
-# This part of Conan configuration is specific to this workflow only; we do not want
-# to pollute conan/profiles directory with settings which might not work for others
-env:
-  CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/dev
-  CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
-  CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
-  CONAN_GLOBAL_CONF: |
-    core.download:parallel={{ os.cpu_count() }}
-    core.upload:parallel={{ os.cpu_count() }}
-    tools.build:jobs={{ (os.cpu_count() * 4/5) | int }}
-    tools.build:verbosity=verbose
-    tools.compilation:verbosity=verbose
-
 # This workflow has multiple job matrixes.
 # They can be considered phases because most of the matrices ("test",
 # "coverage", "conan", ) depend on the first ("dependencies").
@@ -67,45 +54,59 @@ jobs:
           - Release
         include:
           - compiler: gcc
-            compiler_version: 12
-            distro: ubuntu
-            codename: jammy
+            profile:
+              version: 11
+              cc: /usr/bin/gcc
+              cxx: /usr/bin/g++
           - compiler: clang
-            compiler_version: 16
-            distro: debian
-            codename: bookworm
+            profile:
+              version: 14
+              cc: /usr/bin/clang-14
+              cxx: /usr/bin/clang++-14
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/ci/${{ matrix.distro }}-${{ matrix.codename }}:${{ matrix.compiler }}-${{ matrix.compiler_version }}
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
     steps:
+      - name: upgrade conan
+        run: |
+          pip install --upgrade "conan<2"
       - name: checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        uses: actions/checkout@v4
       - name: check environment
         run: |
           echo ${PATH} | tr ':' '\n'
           lsb_release -a || true
-          ${{ matrix.compiler }}-${{ matrix.compiler_version }} --version
+          ${{ matrix.profile.cc }} --version
           conan --version
           cmake --version
           env | sort
       - name: configure Conan
         run: |
-          echo "${CONAN_GLOBAL_CONF}" >> $(conan config home)/global.conf
-          conan config install conan/profiles/ -tf $(conan config home)/profiles/
-          conan profile show
+          conan profile new default --detect
+          conan profile update settings.compiler.cppstd=20 default
+          conan profile update settings.compiler=${{ matrix.compiler }} default
+          conan profile update settings.compiler.version=${{ matrix.profile.version }} default
+          conan profile update settings.compiler.libcxx=libstdc++11 default
+          conan profile update env.CC=${{ matrix.profile.cc }} default
+          conan profile update env.CXX=${{ matrix.profile.cxx }} default
+          conan profile update conf.tools.build:compiler_executables='{"c": "${{ matrix.profile.cc }}", "cpp": "${{ matrix.profile.cxx }}"}' default
       - name: archive profile
         # Create this archive before dependencies are added to the local cache.
-        run: tar -czf conan.tar.gz -C ${CONAN_HOME} .
+        run: tar -czf conan.tar -C ~/.conan .
       - name: build dependencies
         uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+          CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
+          CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
         with:
           configuration: ${{ matrix.configuration }}
       - name: upload archive
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        uses: actions/upload-artifact@v4
         with:
           name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
-          path: conan.tar.gz
+          path: conan.tar
           if-no-files-found: error
 
   test:
@@ -120,32 +121,26 @@ jobs:
         configuration:
           - Debug
           - Release
-        include:
-          - compiler: gcc
-            compiler_version: 12
-            distro: ubuntu
-            codename: jammy
-          - compiler: clang
-            compiler_version: 16
-            distro: debian
-            codename: bookworm
         cmake-args:
           -
           - "-Dunity=ON"
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/ci/${{ matrix.distro }}-${{ matrix.codename }}:${{ matrix.compiler }}-${{ matrix.compiler_version }}
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
     steps:
+      - name: upgrade conan
+        run: |
+          pip install --upgrade "conan<2"
       - name: download cache
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
+        uses: actions/download-artifact@v4
         with:
           name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
       - name: extract cache
         run: |
-          mkdir -p ${CONAN_HOME}
-          tar -xzf conan.tar.gz -C ${CONAN_HOME}
+          mkdir -p ~/.conan
+          tar -xzf conan.tar -C ~/.conan
       - name: check environment
         run: |
           env | sort
@@ -153,9 +148,11 @@ jobs:
           conan --version
           cmake --version
       - name: checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        uses: actions/checkout@v4
       - name: dependencies
         uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
         with:
           configuration: ${{ matrix.configuration }}
       - name: build
@@ -164,16 +161,6 @@ jobs:
           generator: Ninja
           configuration: ${{ matrix.configuration }}
           cmake-args: "-Dassert=TRUE -Dwerr=TRUE ${{ matrix.cmake-args }}"
-      - name: check linking
-        run: |
-          cd ${build_dir}
-          ldd ./rippled
-          if [ "$(ldd ./rippled | grep -E '(libstdc\+\+|libgcc)' | wc -l)" -eq 0 ]; then
-            echo 'The binary is statically linked.'
-          else
-            echo 'The binary is dynamically linked.'
-            exit 1
-          fi
       - name: test
         run: |
           cd ${build_dir}
@@ -195,18 +182,21 @@ jobs:
           - "-DUNIT_TEST_REFERENCE_FEE=1000"
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/ci/ubuntu-jammy:gcc-12
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
     steps:
+      - name: upgrade conan
+        run: |
+          pip install --upgrade "conan<2"
       - name: download cache
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
+        uses: actions/download-artifact@v4
         with:
           name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
       - name: extract cache
         run: |
-          mkdir -p ${CONAN_HOME}
-          tar -xzf conan.tar.gz -C ${CONAN_HOME}
+          mkdir -p ~/.conan
+          tar -xzf conan.tar -C ~/.conan
       - name: check environment
         run: |
           env | sort
@@ -214,9 +204,11 @@ jobs:
           conan --version
           cmake --version
       - name: checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        uses: actions/checkout@v4
       - name: dependencies
         uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
         with:
           configuration: ${{ matrix.configuration }}
       - name: build
@@ -230,7 +222,6 @@ jobs:
           cd ${build_dir}
           ./rippled --unittest --unittest-jobs $(nproc)
           ctest -j $(nproc) --output-on-failure
-
   coverage:
     strategy:
       fail-fast: false
@@ -243,18 +234,23 @@ jobs:
           - Debug
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/ci/ubuntu-jammy:gcc-12
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
     steps:
+      - name: upgrade conan
+        run: |
+          pip install --upgrade "conan<2"
       - name: download cache
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
+        uses: actions/download-artifact@v4
         with:
           name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
       - name: extract cache
         run: |
-          mkdir -p ${CONAN_HOME}
-          tar -xzf conan.tar.gz -C ${CONAN_HOME}
+          mkdir -p ~/.conan
+          tar -xzf conan.tar -C ~/.conan
+      - name: install gcovr
+        run: pip install "gcovr>=7,<9"
       - name: check environment
         run: |
           echo ${PATH} | tr ':' '\n'
@@ -262,11 +258,13 @@ jobs:
           cmake --version
           gcovr --version
           env | sort
-          ls ${CONAN_HOME}
+          ls ~/.conan
       - name: checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        uses: actions/checkout@v4
       - name: dependencies
         uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
         with:
           configuration: ${{ matrix.configuration }}
       - name: build
@@ -288,7 +286,7 @@ jobs:
         run: |
           mv "${build_dir}/coverage.xml" ./
       - name: archive coverage report
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        uses: actions/upload-artifact@v4
         with:
           name: coverage.xml
           path: coverage.xml
@@ -310,23 +308,22 @@ jobs:
   conan:
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container:
-      image: ghcr.io/xrplf/ci/ubuntu-jammy:gcc-12
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
-      platform: linux
-      compiler: gcc
-      compiler_version: 12
       configuration: Release
     steps:
+      - name: upgrade conan
+        run: |
+          pip install --upgrade "conan<2"
       - name: download cache
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
+        uses: actions/download-artifact@v4
         with:
-          name: ${{ env.platform }}-${{ env.compiler }}-${{ env.configuration }}
+          name: linux-gcc-${{ env.configuration }}
       - name: extract cache
         run: |
-          mkdir -p ${CONAN_HOME}
-          tar -xzf conan.tar.gz -C ${CONAN_HOME}
+          mkdir -p ~/.conan
+          tar -xzf conan.tar -C ~/.conan
       - name: check environment
         run: |
           env | sort
@@ -334,66 +331,96 @@ jobs:
           conan --version
           cmake --version
       - name: checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        uses: actions/checkout@v4
       - name: dependencies
         uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
         with:
           configuration: ${{ env.configuration }}
       - name: export
         run: |
-          conan export . --version head
+          version=$(conan inspect --raw version .)
+          reference="xrpl/${version}@local/test"
+          conan remove -f ${reference} || true
+          conan export . local/test
+          echo "reference=${reference}" >> "${GITHUB_ENV}"
       - name: build
         run: |
           cd tests/conan
-          mkdir ${build_dir} && cd ${build_dir}
-          conan install .. \
-            --settings:all build_type=${configuration} \
-            --output-folder . \
-            --build missing
+          mkdir ${build_dir}
+          cd ${build_dir}
+          conan install .. --output-folder . \
+            --require-override ${reference} --build missing
           cmake .. \
             -DCMAKE_TOOLCHAIN_FILE:FILEPATH=./build/${configuration}/generators/conan_toolchain.cmake \
             -DCMAKE_BUILD_TYPE=${configuration}
           cmake --build .
           ./example | grep '^[[:digit:]]\+\.[[:digit:]]\+\.[[:digit:]]\+'
 
+  # NOTE we are not using dependencies built above because it lags with
+  # compiler versions. Instrumentation requires clang version 16 or
+  # later
+
   instrumentation-build:
-    needs: dependencies
-    runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/ci/debian-bookworm:clang-16
+    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     env:
-      build_dir: .build
+      CLANG_RELEASE: 16
+    strategy:
+      fail-fast: false
+    runs-on: [self-hosted, heavy]
+    container: debian:bookworm
     steps:
-        - name: download cache
-          uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
-          with:
-            name: linux-clang-Debug
-
-        - name: extract cache
+        - name: install prerequisites
+          env:
+            DEBIAN_FRONTEND: noninteractive
           run: |
-            mkdir -p ${CONAN_HOME}
-            tar -xzf conan.tar.gz -C ${CONAN_HOME}
-
-        - name: check environment
-          run: |
-            echo ${PATH} | tr ':' '\n'
-            conan --version
-            cmake --version
-            env | sort
-            ls ${CONAN_HOME}
+            apt-get update
+            apt-get install --yes --no-install-recommends \
+              clang-${CLANG_RELEASE} clang++-${CLANG_RELEASE} \
+              python3-pip python-is-python3 make cmake git wget
+            apt-get clean
+            update-alternatives --install \
+              /usr/bin/clang clang /usr/bin/clang-${CLANG_RELEASE} 100 \
+              --slave /usr/bin/clang++ clang++ /usr/bin/clang++-${CLANG_RELEASE}
+            update-alternatives --auto clang
+            pip install --no-cache --break-system-packages "conan<2"
 
         - name: checkout
-          uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-
-        - name: dependencies
-          uses: ./.github/actions/dependencies
-          with:
-            configuration: Debug
+          uses: actions/checkout@v4
 
         - name: prepare environment
           run: |
-            mkdir -p ${build_dir}
-            echo "SOURCE_DIR=$(pwd)" >> $GITHUB_ENV
-            echo "BUILD_DIR=$(pwd)/${build_dir}" >> $GITHUB_ENV
+            mkdir ${GITHUB_WORKSPACE}/.build
+            echo "SOURCE_DIR=$GITHUB_WORKSPACE" >> $GITHUB_ENV
+            echo "BUILD_DIR=$GITHUB_WORKSPACE/.build" >> $GITHUB_ENV
+            echo "CC=/usr/bin/clang" >> $GITHUB_ENV
+            echo "CXX=/usr/bin/clang++" >> $GITHUB_ENV
+
+        - name: configure Conan
+          run: |
+            conan profile new --detect default
+            conan profile update settings.compiler=clang default
+            conan profile update settings.compiler.version=${CLANG_RELEASE} default
+            conan profile update settings.compiler.libcxx=libstdc++11 default
+            conan profile update settings.compiler.cppstd=20 default
+            conan profile update options.rocksdb=False default
+            conan profile update \
+              'conf.tools.build:compiler_executables={"c": "/usr/bin/clang", "cpp": "/usr/bin/clang++"}' default
+            conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_DISABLE_CONCEPTS"' default
+            conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_DISABLE_CONCEPTS"]' default
+            conan export external/snappy snappy/1.1.10@
+            conan export external/soci soci/4.0.3@
+            conan export external/wamr wamr/2.3.1@
+
+        - name: build dependencies
+          run: |
+            cd ${BUILD_DIR}
+            conan install ${SOURCE_DIR} \
+              --output-folder ${BUILD_DIR} \
+              --install-folder ${BUILD_DIR} \
+              --build missing \
+              --settings build_type=Debug
 
         - name: build with instrumentation
           run: |

.github/workflows/windows.yml

@@ -18,18 +18,6 @@ on:
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
-# This part of Conan configuration is specific to this workflow only; we do not want
-# to pollute conan/profiles directory with settings which might not work for others
-env:
-  CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/dev
-  CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
-  CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
-  CONAN_GLOBAL_CONF: |
-    core.download:parallel={{os.cpu_count()}}
-    core.upload:parallel={{os.cpu_count()}}
-    tools.build:jobs=24
-    tools.build:verbosity=verbose
-    tools.compilation:verbosity=verbose
 
 jobs:
 
@@ -54,11 +42,11 @@ jobs:
       build_dir: .build
     steps:
       - name: checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        uses: actions/checkout@v4
       - name: choose Python
-        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065
+        uses: actions/setup-python@v5
         with:
-          python-version: 3.13
+          python-version: 3.9
       - name: learn Python cache directory
         id: pip-cache
         shell: bash
@@ -66,12 +54,12 @@ jobs:
           python -m pip install --upgrade pip
           echo "dir=$(pip cache dir)" | tee ${GITHUB_OUTPUT}
       - name: restore Python cache directory
-        uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684
+        uses: actions/cache@v4
         with:
             path: ${{ steps.pip-cache.outputs.dir }}
             key: ${{ runner.os }}-${{ hashFiles('.github/workflows/windows.yml') }}
       - name: install Conan
-        run: pip install wheel conan
+        run: pip install wheel 'conan<2'
       - name: check environment
         run: |
           dir env:
@@ -82,26 +70,17 @@ jobs:
       - name: configure Conan
         shell: bash
         run: |
-          echo "${CONAN_GLOBAL_CONF}" >> $(conan config home)/global.conf
-          conan config install conan/profiles/ -tf $(conan config home)/profiles/
-          conan profile show
-      - name: export custom recipes
-        shell: bash
-        run: |
-          conan export --version 1.1.10 external/snappy
-          conan export --version 4.0.3 external/soci
-      - name: add Ripple Conan remote
-        if: env.CONAN_URL != ''
-        shell: bash
-        run: |
-          if conan remote list | grep -q "ripple"; then
-              conan remote remove ripple
-              echo "Removed conan remote ripple"
-          fi
-          conan remote add --index 0 ripple "${CONAN_URL}"
-          echo "Added conan remote ripple at ${CONAN_URL}"
+          conan profile new default --detect
+          conan profile update settings.compiler.cppstd=20 default
+          conan profile update \
+            settings.compiler.runtime=MT${{ matrix.configuration.runtime }} \
+            default
       - name: build dependencies
         uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+          CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
+          CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
         with:
           configuration: ${{ matrix.configuration.type }}
       - name: build

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 # .pre-commit-config.yaml
 repos:
 - repo: https://github.com/pre-commit/mirrors-clang-format
-  rev: v18.1.8
+  rev: v18.1.3
   hooks:
   - id: clang-format

BUILD.md

@@ -167,18 +167,54 @@ It does not explicitly link the C++ standard library,
 which allows you to statically link it with GCC, if you want.
 
    ```
+   # Conan 1.x
+   conan export external/snappy snappy/1.1.10@
    # Conan 2.x
    conan export --version 1.1.10 external/snappy
    ```
 
+Export our [Conan recipe for RocksDB](./external/rocksdb).
+It does not override paths to dependencies when building with Visual Studio.
+
+   ```
+   # Conan 1.x
+   conan export external/rocksdb rocksdb/9.7.3@
+   # Conan 2.x
+   conan export --version 9.7.3 external/rocksdb
+   ```
+
 Export our [Conan recipe for SOCI](./external/soci).
 It patches their CMake to correctly import its dependencies.
 
    ```
+   # Conan 1.x
+   conan export external/soci soci/4.0.3@
    # Conan 2.x
    conan export --version 4.0.3 external/soci
    ```
 
+Export our [Conan recipe for NuDB](./external/nudb).
+It fixes some source files to add missing `#include`s.
+
+
+   ```
+   # Conan 1.x
+   conan export external/nudb nudb/2.0.8@
+   # Conan 2.x
+   conan export --version 2.0.8 external/nudb
+   ```
+
+Export our [Conan recipe for WAMR](./external/wamr).
+It add metering and expose some internal structures.
+
+
+   ```
+   # Conan 1.x
+   conan export external/wamr wamr/2.3.1@
+   # Conan 2.x
+   conan export --version 2.3.1 external/wamr
+   ```
+
 ### Build and Test
 
 1. Create a build directory and move into it.
@@ -370,13 +406,18 @@ and can be helpful for detecting `#include` omissions.
 
 ## Troubleshooting
 
+
 ### Conan
 
 After any updates or changes to dependencies, you may need to do the following:
 
 1. Remove your build directory.
-2. Remove the Conan cache: `conan remove "*" -c`
-3. Re-run [conan install](#build-and-test).
+2. Remove the Conan cache:
+   ```
+   rm -rf ~/.conan/data
+   ```
+4. Re-run [conan install](#build-and-test).
+
 
 ### 'protobuf/port_def.inc' file not found
 
@@ -394,6 +435,54 @@ For example, if you want to build Debug:
 1. For conan install, pass `--settings build_type=Debug`
 2. For cmake, pass `-DCMAKE_BUILD_TYPE=Debug`
 
+
+### no std::result_of
+
+If your compiler version is recent enough to have removed `std::result_of` as
+part of C++20, e.g. Apple Clang 15.0, then you might need to add a preprocessor
+definition to your build.
+
+```
+conan profile update 'options.boost:extra_b2_flags="define=BOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
+conan profile update 'env.CFLAGS="-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
+conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
+conan profile update 'conf.tools.build:cflags+=["-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"]' default
+conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"]' default
+```
+
+
+### call to 'async_teardown' is ambiguous
+
+If you are compiling with an early version of Clang 16, then you might hit
+a [regression][6] when compiling C++20 that manifests as an [error in a Boost
+header][7]. You can workaround it by adding this preprocessor definition:
+
+```
+conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_DISABLE_CONCEPTS"' default
+conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_DISABLE_CONCEPTS"]' default
+```
+
+
+### recompile with -fPIC
+
+If you get a linker error suggesting that you recompile Boost with
+position-independent code, such as:
+
+```
+/usr/bin/ld.gold: error: /home/username/.conan/data/boost/1.77.0/_/_/package/.../lib/libboost_container.a(alloc_lib.o):
+  requires unsupported dynamic reloc 11; recompile with -fPIC
+```
+
+Conan most likely downloaded a bad binary distribution of the dependency.
+This seems to be a [bug][1] in Conan just for Boost 1.77.0 compiled with GCC
+for Linux. The solution is to build the dependency locally by passing
+`--build boost` when calling `conan install`.
+
+```
+conan install --build boost ...
+```
+
+
 ## Add a Dependency
 
 If you want to experiment with a new package, follow these steps:

CMakeLists.txt

@@ -120,6 +120,7 @@ endif()
 find_package(nudb REQUIRED)
 find_package(date REQUIRED)
 find_package(xxHash REQUIRED)
+find_package(wamr REQUIRED)
 
 target_link_libraries(ripple_libs INTERFACE
   ed25519::ed25519

cfg/rippled-example.cfg

@@ -1249,6 +1249,39 @@
 #       Example:
 #           owner_reserve = 2000000      # 2 XRP
 #
+#   extension_compute_limit = <gas>
+#
+#       The extension compute limit is the maximum amount of gas that can be
+#       consumed by a single transaction. The gas limit is used to prevent
+#       transactions from consuming too many resources.
+#
+#       If this parameter is unspecified, rippled will use an internal
+#       default. Don't change this without understanding the consequences.
+#
+#       Example:
+#           extension_compute_limit = 1000000      # 1 million gas
+#
+#   extension_size_limit = <bytes>
+#
+#       The extension size limit is the maximum size of a WASM extension in
+#       bytes. The size limit is used to prevent extensions from consuming
+#       too many resources.
+#
+#       If this parameter is unspecified, rippled will use an internal
+#       default. Don't change this without understanding the consequences.
+#
+#       Example:
+#           extension_size_limit = 100000      # 100 kb
+#
+#   gas_price = <bytes>
+#
+#       The gas price is the conversion between WASM gas and its price in drops.
+#
+#       If this parameter is unspecified, rippled will use an internal
+#       default. Don't change this without understanding the consequences.
+#
+#       Example:
+#           gas_price = 1000000      # 1 drop per gas
 #-------------------------------------------------------------------------------
 #
 # 9. Misc Settings

cmake/RippledCompiler.cmake

@@ -90,15 +90,28 @@ if (MSVC)
       -errorreport:none
       -machine:X64)
 else ()
+  # HACK : because these need to come first, before any warning demotion
+  string (APPEND CMAKE_CXX_FLAGS " -Wall -Wdeprecated")
+  if (wextra)
+    string (APPEND CMAKE_CXX_FLAGS " -Wextra -Wno-unused-parameter")
+  endif ()
+  # not MSVC
   target_compile_options (common
     INTERFACE
-      -Wall
-      -Wdeprecated
-      $<$<BOOL:${wextra}>:-Wextra -Wno-unused-parameter>
       $<$<BOOL:${werr}>:-Werror>
-      -fstack-protector
+      $<$<COMPILE_LANGUAGE:CXX>:
+        -frtti
+        -Wnon-virtual-dtor
+      >
       -Wno-sign-compare
-      -Wno-unused-but-set-variable
+      -Wno-char-subscripts
+      -Wno-format
+      -Wno-unused-local-typedefs
+      -fstack-protector
+      $<$<BOOL:${is_gcc}>:
+        -Wno-unused-but-set-variable
+        -Wno-deprecated
+      >
       $<$<NOT:$<CONFIG:Debug>>:-fno-strict-aliasing>
       # tweak gcc optimization for debug
       $<$<AND:$<BOOL:${is_gcc}>,$<CONFIG:Debug>>:-O0>

cmake/RippledCore.cmake

@@ -65,6 +65,7 @@ target_link_libraries(xrpl.imports.main
     xrpl.libpb
     xxHash::xxhash
     $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>
+    wamr::wamr
 )
 
 include(add_module)

cmake/RippledSettings.cmake

@@ -18,7 +18,7 @@ if(tests)
   endif()
 endif()
 
-option(unity "Creates a build using UNITY support in cmake." OFF)
+option(unity "Creates a build using UNITY support in cmake. This is the default" ON)
 if(unity)
   if(NOT is_ci)
     set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")

cmake/deps/Boost.cmake

@@ -2,6 +2,7 @@ find_package(Boost 1.82 REQUIRED
   COMPONENTS
     chrono
     container
+    context
     coroutine
     date_time
     filesystem
@@ -23,7 +24,7 @@ endif()
 
 target_link_libraries(ripple_boost
   INTERFACE
-    Boost::headers
+    Boost::boost
     Boost::chrono
     Boost::container
     Boost::coroutine

conan/profiles/default

@@ -1,34 +0,0 @@
-{% set os = detect_api.detect_os() %}
-{% set arch = detect_api.detect_arch() %}
-{% set compiler, version, compiler_exe = detect_api.detect_default_compiler() %}
-{% set compiler_version = version %}
-{% if os == "Linux" %}
-{% set compiler_version = detect_api.default_compiler_version(compiler, version) %}
-{% endif %}
-
-[settings]
-os={{ os }}
-arch={{ arch }}
-build_type=Debug
-compiler={{compiler}}
-compiler.version={{ compiler_version }}
-compiler.cppstd=20
-{% if os == "Windows" %}
-compiler.runtime=static
-{% else %}
-compiler.libcxx={{detect_api.detect_libcxx(compiler, version, compiler_exe)}}
-{% endif %}
-
-[conf]
-{% if compiler == "clang" and compiler_version >= 19 %}
-tools.build:cxxflags=['-Wno-missing-template-arg-list-after-template-kw']
-{% endif %}
-{% if compiler == "apple-clang" and compiler_version >= 17 %}
-tools.build:cxxflags=['-Wno-missing-template-arg-list-after-template-kw']
-{% endif %}
-{% if compiler == "gcc" and compiler_version < 13 %}
-tools.build:cxxflags=['-Wno-restrict']
-{% endif %}
-
-[tool_requires]
-!cmake/*: cmake/[>=3 <4]

conanfile.py

@@ -2,6 +2,7 @@ from conan import ConanFile, __version__ as conan_version
 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
 import re
 
+
 class Xrpl(ConanFile):
     name = 'xrpl'
 
@@ -24,20 +25,18 @@ class Xrpl(ConanFile):
     }
 
     requires = [
+        'doctest/2.4.11',
         'grpc/1.50.1',
-        'libarchive/3.8.1',
-        'nudb/2.0.9',
-        'openssl/1.1.1w',
+        'libarchive/3.7.6',
+        'nudb/2.0.8',
+        'openssl/1.1.1v',
         'soci/4.0.3',
         'zlib/1.3.1',
-    ]
-
-    test_requires = [
-        'doctest/2.4.11',
+        'wamr/2.3.1',
     ]
 
     tool_requires = [
-        'protobuf/3.21.12',
+        'protobuf/3.21.9',
     ]
 
     default_options = {
@@ -89,13 +88,12 @@ class Xrpl(ConanFile):
     }
 
     def set_version(self):
-        if self.version is None:
-            path = f'{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp'
-            regex = r'versionString\s?=\s?\"(.*)\"'
-            with open(path, encoding='utf-8') as file:
-                matches = (re.search(regex, line) for line in file)
-                match = next(m for m in matches if m)
-                self.version = match.group(1)
+        path = f'{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp'
+        regex = r'versionString\s?=\s?\"(.*)\"'
+        with open(path, 'r') as file:
+            matches = (re.search(regex, line) for line in file)
+            match = next(m for m in matches if m)
+            self.version = match.group(1)
 
     def configure(self):
         if self.settings.compiler == 'apple-clang':
@@ -104,16 +102,16 @@ class Xrpl(ConanFile):
     def requirements(self):
         # Conan 2 requires transitive headers to be specified
         transitive_headers_opt = {'transitive_headers': True} if conan_version.split('.')[0] == '2' else {}
-        self.requires('boost/1.86.0', force=True, **transitive_headers_opt)
-        self.requires('date/3.0.4', **transitive_headers_opt)
+        self.requires('boost/1.83.0', force=True, **transitive_headers_opt)
+        self.requires('date/3.0.3', **transitive_headers_opt)
         self.requires('lz4/1.10.0', force=True)
-        self.requires('protobuf/3.21.12', force=True)
-        self.requires('sqlite3/3.49.1', force=True)
+        self.requires('protobuf/3.21.9', force=True)
+        self.requires('sqlite3/3.47.0', force=True)
         if self.options.jemalloc:
             self.requires('jemalloc/5.3.0')
         if self.options.rocksdb:
-            self.requires('rocksdb/10.0.1')
-        self.requires('xxhash/0.8.3', **transitive_headers_opt)
+            self.requires('rocksdb/9.7.3')
+        self.requires('xxhash/0.8.2', **transitive_headers_opt)
 
     exports_sources = (
         'CMakeLists.txt',
@@ -132,6 +130,7 @@ class Xrpl(ConanFile):
         self.folders.generators = 'build/generators'
 
     generators = 'CMakeDeps'
+
     def generate(self):
         tc = CMakeToolchain(self)
         tc.variables['tests'] = self.options.tests
@@ -168,17 +167,7 @@ class Xrpl(ConanFile):
         # `include/`, not `include/ripple/proto/`.
         libxrpl.includedirs = ['include', 'include/ripple/proto']
         libxrpl.requires = [
-            'boost::headers',
-            'boost::chrono',
-            'boost::container',
-            'boost::coroutine',
-            'boost::date_time',
-            'boost::filesystem',
-            'boost::json',
-            'boost::program_options',
-            'boost::regex',
-            'boost::system',
-            'boost::thread',
+            'boost::boost',
             'date::date',
             'grpc::grpc++',
             'libarchive::libarchive',

external/antithesis-sdk/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.25)
 
 # Note, version set explicitly by rippled project
 project(antithesis-sdk-cpp VERSION 0.4.4 LANGUAGES CXX)

external/ed25519-donna/CMakeLists.txt

@@ -17,9 +17,6 @@ add_library(ed25519 STATIC
 )
 add_library(ed25519::ed25519 ALIAS ed25519)
 target_link_libraries(ed25519 PUBLIC OpenSSL::SSL)
-if(NOT MSVC)
-  target_compile_options(ed25519 PRIVATE -Wno-implicit-fallthrough)
-endif()
 
 include(GNUInstallDirs)
 

external/nudb/conandata.yml

@@ -0,0 +1,10 @@
+sources:
+  "2.0.8":
+    url: "https://github.com/CPPAlliance/NuDB/archive/2.0.8.tar.gz"
+    sha256: "9b71903d8ba111cd893ab064b9a8b6ac4124ed8bd6b4f67250205bc43c7f13a8"
+patches:
+  "2.0.8":
+    - patch_file: "patches/2.0.8-0001-add-include-stdexcept-for-msvc.patch"
+      patch_description: "Fix build for MSVC by including stdexcept"
+      patch_type: "portability"
+      patch_source: "https://github.com/cppalliance/NuDB/pull/100/files"

external/nudb/conanfile.py

@@ -0,0 +1,72 @@
+import os
+
+from conan import ConanFile
+from conan.tools.build import check_min_cppstd
+from conan.tools.files import apply_conandata_patches, copy, export_conandata_patches, get
+from conan.tools.layout import basic_layout
+
+required_conan_version = ">=1.52.0"
+
+
+class NudbConan(ConanFile):
+    name = "nudb"
+    description = "A fast key/value insert-only database for SSD drives in C++11"
+    license = "BSL-1.0"
+    url = "https://github.com/conan-io/conan-center-index"
+    homepage = "https://github.com/CPPAlliance/NuDB"
+    topics = ("header-only", "KVS", "insert-only")
+
+    package_type = "header-library"
+    settings = "os", "arch", "compiler", "build_type"
+    no_copy_source = True
+
+    @property
+    def _min_cppstd(self):
+        return 11
+
+    def export_sources(self):
+        export_conandata_patches(self)
+
+    def layout(self):
+        basic_layout(self, src_folder="src")
+
+    def requirements(self):
+        self.requires("boost/1.83.0")
+
+    def package_id(self):
+        self.info.clear()
+
+    def validate(self):
+        if self.settings.compiler.cppstd:
+            check_min_cppstd(self, self._min_cppstd)
+
+    def source(self):
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
+
+    def build(self):
+        apply_conandata_patches(self)
+
+    def package(self):
+        copy(self, "LICENSE*",
+             dst=os.path.join(self.package_folder, "licenses"),
+             src=self.source_folder)
+        copy(self, "*",
+             dst=os.path.join(self.package_folder, "include"),
+             src=os.path.join(self.source_folder, "include"))
+
+    def package_info(self):
+        self.cpp_info.bindirs = []
+        self.cpp_info.libdirs = []
+
+        self.cpp_info.set_property("cmake_target_name", "NuDB")
+        self.cpp_info.set_property("cmake_target_aliases", ["NuDB::nudb"])
+        self.cpp_info.set_property("cmake_find_mode", "both")
+
+        self.cpp_info.components["core"].set_property("cmake_target_name", "nudb")
+        self.cpp_info.components["core"].names["cmake_find_package"] = "nudb"
+        self.cpp_info.components["core"].names["cmake_find_package_multi"] = "nudb"
+        self.cpp_info.components["core"].requires = ["boost::thread", "boost::system"]
+
+        # TODO: to remove in conan v2 once cmake_find_package_* generators removed
+        self.cpp_info.names["cmake_find_package"] = "NuDB"
+        self.cpp_info.names["cmake_find_package_multi"] = "NuDB"

external/nudb/patches/2.0.8-0001-add-include-stdexcept-for-msvc.patch

@@ -0,0 +1,24 @@
+diff --git a/include/nudb/detail/stream.hpp b/include/nudb/detail/stream.hpp
+index 6c07bf1..e0ce8ed 100644
+--- a/include/nudb/detail/stream.hpp
++++ b/include/nudb/detail/stream.hpp
+@@ -14,6 +14,7 @@
+ #include <cstdint>
+ #include <cstring>
+ #include <memory>
++#include <stdexcept>
+ 
+ namespace nudb {
+ namespace detail {
+diff --git a/include/nudb/impl/context.ipp b/include/nudb/impl/context.ipp
+index beb7058..ffde0b3 100644
+--- a/include/nudb/impl/context.ipp
++++ b/include/nudb/impl/context.ipp
+@@ -9,6 +9,7 @@
+ #define NUDB_IMPL_CONTEXT_IPP
+ 
+ #include <nudb/detail/store_base.hpp>
++#include <stdexcept>
+ 
+ namespace nudb {
+ 

external/rocksdb/conandata.yml

@@ -0,0 +1,12 @@
+sources:
+  "9.7.3":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v9.7.3.tar.gz"
+    sha256: "acfabb989cbfb5b5c4d23214819b059638193ec33dad2d88373c46448d16d38b"
+patches:
+  "9.7.3":
+    - patch_file: "patches/9.x.x-0001-exclude-thirdparty.patch"
+      patch_description: "Do not include thirdparty.inc"
+      patch_type: "portability"
+    - patch_file: "patches/9.7.3-0001-memory-leak.patch"
+      patch_description: "Fix a leak of obsolete blob files left open until DB::Close()"
+      patch_type: "portability"

external/rocksdb/conanfile.py

@@ -0,0 +1,235 @@
+import os
+import glob
+import shutil
+
+from conan import ConanFile
+from conan.errors import ConanInvalidConfiguration
+from conan.tools.build import check_min_cppstd
+from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
+from conan.tools.files import apply_conandata_patches, collect_libs, copy, export_conandata_patches, get, rm, rmdir
+from conan.tools.microsoft import check_min_vs, is_msvc, is_msvc_static_runtime
+from conan.tools.scm import Version
+
+required_conan_version = ">=1.53.0"
+
+
+class RocksDBConan(ConanFile):
+    name = "rocksdb"
+    description = "A library that provides an embeddable, persistent key-value store for fast storage"
+    license = ("GPL-2.0-only", "Apache-2.0")
+    url = "https://github.com/conan-io/conan-center-index"
+    homepage = "https://github.com/facebook/rocksdb"
+    topics = ("database", "leveldb", "facebook", "key-value")
+    package_type = "library"
+    settings = "os", "arch", "compiler", "build_type"
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+        "lite": [True, False],
+        "with_gflags": [True, False],
+        "with_snappy": [True, False],
+        "with_lz4": [True, False],
+        "with_zlib": [True, False],
+        "with_zstd": [True, False],
+        "with_tbb": [True, False],
+        "with_jemalloc": [True, False],
+        "enable_sse": [False, "sse42", "avx2"],
+        "use_rtti": [True, False],
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+        "lite": False,
+        "with_snappy": False,
+        "with_lz4": False,
+        "with_zlib": False,
+        "with_zstd": False,
+        "with_gflags": False,
+        "with_tbb": False,
+        "with_jemalloc": False,
+        "enable_sse": False,
+        "use_rtti": False,
+    }
+
+    @property
+    def _min_cppstd(self):
+        return "11" if Version(self.version) < "8.8.1" else "17"
+
+    @property
+    def _compilers_minimum_version(self):
+        return {} if self._min_cppstd == "11" else {
+            "apple-clang": "10",
+            "clang": "7",
+            "gcc": "7",
+            "msvc": "191",
+            "Visual Studio": "15",
+        }
+
+    def export_sources(self):
+        export_conandata_patches(self)
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            del self.options.fPIC
+        if self.settings.arch != "x86_64":
+            del self.options.with_tbb
+        if self.settings.build_type == "Debug":
+            self.options.use_rtti = True  # Rtti are used in asserts for debug mode...
+
+    def configure(self):
+        if self.options.shared:
+            self.options.rm_safe("fPIC")
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
+    def requirements(self):
+        if self.options.with_gflags:
+            self.requires("gflags/2.2.2")
+        if self.options.with_snappy:
+            self.requires("snappy/1.1.10")
+        if self.options.with_lz4:
+            self.requires("lz4/1.10.0")
+        if self.options.with_zlib:
+            self.requires("zlib/[>=1.2.11 <2]")
+        if self.options.with_zstd:
+            self.requires("zstd/1.5.6")
+        if self.options.get_safe("with_tbb"):
+            self.requires("onetbb/2021.12.0")
+        if self.options.with_jemalloc:
+            self.requires("jemalloc/5.3.0")
+
+    def validate(self):
+        if self.settings.compiler.get_safe("cppstd"):
+            check_min_cppstd(self, self._min_cppstd)
+
+        minimum_version = self._compilers_minimum_version.get(str(self.settings.compiler), False)
+        if minimum_version and Version(self.settings.compiler.version) < minimum_version:
+            raise ConanInvalidConfiguration(
+                f"{self.ref} requires C++{self._min_cppstd}, which your compiler does not support."
+            )
+
+        if self.settings.arch not in ["x86_64", "ppc64le", "ppc64", "mips64", "armv8"]:
+            raise ConanInvalidConfiguration("Rocksdb requires 64 bits")
+
+        check_min_vs(self, "191")
+
+        if self.version == "6.20.3" and \
+                self.settings.os == "Linux" and \
+                self.settings.compiler == "gcc" and \
+                Version(self.settings.compiler.version) < "5":
+            raise ConanInvalidConfiguration("Rocksdb 6.20.3 is not compilable with gcc <5.") # See https://github.com/facebook/rocksdb/issues/3522
+
+    def source(self):
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["FAIL_ON_WARNINGS"] = False
+        tc.variables["WITH_TESTS"] = False
+        tc.variables["WITH_TOOLS"] = False
+        tc.variables["WITH_CORE_TOOLS"] = False
+        tc.variables["WITH_BENCHMARK_TOOLS"] = False
+        tc.variables["WITH_FOLLY_DISTRIBUTED_MUTEX"] = False
+        if is_msvc(self):
+            tc.variables["WITH_MD_LIBRARY"] = not is_msvc_static_runtime(self)
+        tc.variables["ROCKSDB_INSTALL_ON_WINDOWS"] = self.settings.os == "Windows"
+        tc.variables["ROCKSDB_LITE"] = self.options.lite
+        tc.variables["WITH_GFLAGS"] = self.options.with_gflags
+        tc.variables["WITH_SNAPPY"] = self.options.with_snappy
+        tc.variables["WITH_LZ4"] = self.options.with_lz4
+        tc.variables["WITH_ZLIB"] = self.options.with_zlib
+        tc.variables["WITH_ZSTD"] = self.options.with_zstd
+        tc.variables["WITH_TBB"] = self.options.get_safe("with_tbb", False)
+        tc.variables["WITH_JEMALLOC"] = self.options.with_jemalloc
+        tc.variables["ROCKSDB_BUILD_SHARED"] = self.options.shared
+        tc.variables["ROCKSDB_LIBRARY_EXPORTS"] = self.settings.os == "Windows" and self.options.shared
+        tc.variables["ROCKSDB_DLL" ] = self.settings.os == "Windows" and self.options.shared
+        tc.variables["USE_RTTI"] = self.options.use_rtti
+        if not bool(self.options.enable_sse):
+            tc.variables["PORTABLE"] = True
+            tc.variables["FORCE_SSE42"] = False
+        elif self.options.enable_sse == "sse42":
+            tc.variables["PORTABLE"] = True
+            tc.variables["FORCE_SSE42"] = True
+        elif self.options.enable_sse == "avx2":
+            tc.variables["PORTABLE"] = False
+            tc.variables["FORCE_SSE42"] = False
+        # not available yet in CCI
+        tc.variables["WITH_NUMA"] = False
+        tc.generate()
+
+        deps = CMakeDeps(self)
+        if self.options.with_jemalloc:
+            deps.set_property("jemalloc", "cmake_file_name", "JeMalloc")
+            deps.set_property("jemalloc", "cmake_target_name", "JeMalloc::JeMalloc")
+        if self.options.with_zstd:
+            deps.set_property("zstd", "cmake_target_name", "zstd::zstd")
+        deps.generate()
+
+    def build(self):
+        apply_conandata_patches(self)
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def _remove_static_libraries(self):
+        rm(self, "rocksdb.lib", os.path.join(self.package_folder, "lib"))
+        for lib in glob.glob(os.path.join(self.package_folder, "lib", "*.a")):
+            if not lib.endswith(".dll.a"):
+                os.remove(lib)
+
+    def _remove_cpp_headers(self):
+        for path in glob.glob(os.path.join(self.package_folder, "include", "rocksdb", "*")):
+            if path != os.path.join(self.package_folder, "include", "rocksdb", "c.h"):
+                if os.path.isfile(path):
+                    os.remove(path)
+                else:
+                    shutil.rmtree(path)
+
+    def package(self):
+        copy(self, "COPYING", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
+        copy(self, "LICENSE*", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
+        cmake = CMake(self)
+        cmake.install()
+        if self.options.shared:
+            self._remove_static_libraries()
+            self._remove_cpp_headers() # Force stable ABI for shared libraries
+        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
+        rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
+
+    def package_info(self):
+        cmake_target = "rocksdb-shared" if self.options.shared else "rocksdb"
+        self.cpp_info.set_property("cmake_file_name", "RocksDB")
+        self.cpp_info.set_property("cmake_target_name", f"RocksDB::{cmake_target}")
+        # TODO: back to global scope in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.components["librocksdb"].libs = collect_libs(self)
+        if self.settings.os == "Windows":
+            self.cpp_info.components["librocksdb"].system_libs = ["shlwapi", "rpcrt4"]
+            if self.options.shared:
+                self.cpp_info.components["librocksdb"].defines = ["ROCKSDB_DLL"]
+        elif self.settings.os in ["Linux", "FreeBSD"]:
+            self.cpp_info.components["librocksdb"].system_libs = ["pthread", "m"]
+        if self.options.lite:
+            self.cpp_info.components["librocksdb"].defines.append("ROCKSDB_LITE")
+
+        # TODO: to remove in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.names["cmake_find_package"] = "RocksDB"
+        self.cpp_info.names["cmake_find_package_multi"] = "RocksDB"
+        self.cpp_info.components["librocksdb"].names["cmake_find_package"] = cmake_target
+        self.cpp_info.components["librocksdb"].names["cmake_find_package_multi"] = cmake_target
+        self.cpp_info.components["librocksdb"].set_property("cmake_target_name", f"RocksDB::{cmake_target}")
+        if self.options.with_gflags:
+            self.cpp_info.components["librocksdb"].requires.append("gflags::gflags")
+        if self.options.with_snappy:
+            self.cpp_info.components["librocksdb"].requires.append("snappy::snappy")
+        if self.options.with_lz4:
+            self.cpp_info.components["librocksdb"].requires.append("lz4::lz4")
+        if self.options.with_zlib:
+            self.cpp_info.components["librocksdb"].requires.append("zlib::zlib")
+        if self.options.with_zstd:
+            self.cpp_info.components["librocksdb"].requires.append("zstd::zstd")
+        if self.options.get_safe("with_tbb"):
+            self.cpp_info.components["librocksdb"].requires.append("onetbb::onetbb")
+        if self.options.with_jemalloc:
+            self.cpp_info.components["librocksdb"].requires.append("jemalloc::jemalloc")

external/rocksdb/patches/9.7.3-0001-memory-leak.patch

@@ -0,0 +1,319 @@
+diff --git a/HISTORY.md b/HISTORY.md
+index 36d472229..05ad1a202 100644
+--- a/HISTORY.md
++++ b/HISTORY.md
+@@ -1,6 +1,10 @@
+ # Rocksdb Change Log
+ > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt`
+ 
++## 9.7.4 (10/31/2024)
++### Bug Fixes
++* Fix a leak of obsolete blob files left open until DB::Close(). This bug was introduced in version 9.4.0.
++
+ ## 9.7.3 (10/16/2024)
+ ### Behavior Changes
+ * OPTIONS file to be loaded by remote worker is now preserved so that it does not get purged by the primary host. A similar technique as how we are preserving new SST files from getting purged is used for this. min_options_file_numbers_ is tracked like pending_outputs_ is tracked.
+diff --git a/db/blob/blob_file_cache.cc b/db/blob/blob_file_cache.cc
+index 5f340aadf..1b9faa238 100644
+--- a/db/blob/blob_file_cache.cc
++++ b/db/blob/blob_file_cache.cc
+@@ -42,6 +42,7 @@ Status BlobFileCache::GetBlobFileReader(
+   assert(blob_file_reader);
+   assert(blob_file_reader->IsEmpty());
+ 
++  // NOTE: sharing same Cache with table_cache
+   const Slice key = GetSliceForKey(&blob_file_number);
+ 
+   assert(cache_);
+@@ -98,4 +99,13 @@ Status BlobFileCache::GetBlobFileReader(
+   return Status::OK();
+ }
+ 
++void BlobFileCache::Evict(uint64_t blob_file_number) {
++  // NOTE: sharing same Cache with table_cache
++  const Slice key = GetSliceForKey(&blob_file_number);
++
++  assert(cache_);
++
++  cache_.get()->Erase(key);
++}
++
+ }  // namespace ROCKSDB_NAMESPACE
+diff --git a/db/blob/blob_file_cache.h b/db/blob/blob_file_cache.h
+index 740e67ada..6858d012b 100644
+--- a/db/blob/blob_file_cache.h
++++ b/db/blob/blob_file_cache.h
+@@ -36,6 +36,15 @@ class BlobFileCache {
+                            uint64_t blob_file_number,
+                            CacheHandleGuard<BlobFileReader>* blob_file_reader);
+ 
++  // Called when a blob file is obsolete to ensure it is removed from the cache
++  // to avoid effectively leaking the open file and assicated memory
++  void Evict(uint64_t blob_file_number);
++
++  // Used to identify cache entries for blob files (not normally useful)
++  static const Cache::CacheItemHelper* GetHelper() {
++    return CacheInterface::GetBasicHelper();
++  }
++
+  private:
+   using CacheInterface =
+       BasicTypedCacheInterface<BlobFileReader, CacheEntryRole::kMisc>;
+diff --git a/db/column_family.h b/db/column_family.h
+index e4b7adde8..86637736a 100644
+--- a/db/column_family.h
++++ b/db/column_family.h
+@@ -401,6 +401,7 @@ class ColumnFamilyData {
+                          SequenceNumber earliest_seq);
+ 
+   TableCache* table_cache() const { return table_cache_.get(); }
++  BlobFileCache* blob_file_cache() const { return blob_file_cache_.get(); }
+   BlobSource* blob_source() const { return blob_source_.get(); }
+ 
+   // See documentation in compaction_picker.h
+diff --git a/db/db_impl/db_impl.cc b/db/db_impl/db_impl.cc
+index 261593423..06573ac2e 100644
+--- a/db/db_impl/db_impl.cc
++++ b/db/db_impl/db_impl.cc
+@@ -659,8 +659,9 @@ Status DBImpl::CloseHelper() {
+   // We need to release them before the block cache is destroyed. The block
+   // cache may be destroyed inside versions_.reset(), when column family data
+   // list is destroyed, so leaving handles in table cache after
+-  // versions_.reset() may cause issues.
+-  // Here we clean all unreferenced handles in table cache.
++  // versions_.reset() may cause issues. Here we clean all unreferenced handles
++  // in table cache, and (for certain builds/conditions) assert that no obsolete
++  // files are hanging around unreferenced (leak) in the table/blob file cache.
+   // Now we assume all user queries have finished, so only version set itself
+   // can possibly hold the blocks from block cache. After releasing unreferenced
+   // handles here, only handles held by version set left and inside
+@@ -668,6 +669,9 @@ Status DBImpl::CloseHelper() {
+   // time a handle is released, we erase it from the cache too. By doing that,
+   // we can guarantee that after versions_.reset(), table cache is empty
+   // so the cache can be safely destroyed.
++#ifndef NDEBUG
++  TEST_VerifyNoObsoleteFilesCached(/*db_mutex_already_held=*/true);
++#endif  // !NDEBUG
+   table_cache_->EraseUnRefEntries();
+ 
+   for (auto& txn_entry : recovered_transactions_) {
+@@ -3227,6 +3231,8 @@ Status DBImpl::MultiGetImpl(
+       s = Status::Aborted();
+       break;
+     }
++    // This could be a long-running operation
++    ROCKSDB_THREAD_YIELD_HOOK();
+   }
+ 
+   // Post processing (decrement reference counts and record statistics)
+diff --git a/db/db_impl/db_impl.h b/db/db_impl/db_impl.h
+index 5e4fa310b..ccc0abfa7 100644
+--- a/db/db_impl/db_impl.h
++++ b/db/db_impl/db_impl.h
+@@ -1241,9 +1241,14 @@ class DBImpl : public DB {
+   static Status TEST_ValidateOptions(const DBOptions& db_options) {
+     return ValidateOptions(db_options);
+   }
+-
+ #endif  // NDEBUG
+ 
++  // In certain configurations, verify that the table/blob file cache only
++  // contains entries for live files, to check for effective leaks of open
++  // files. This can only be called when purging of obsolete files has
++  // "settled," such as during parts of DB Close().
++  void TEST_VerifyNoObsoleteFilesCached(bool db_mutex_already_held) const;
++
+   // persist stats to column family "_persistent_stats"
+   void PersistStats();
+ 
+diff --git a/db/db_impl/db_impl_debug.cc b/db/db_impl/db_impl_debug.cc
+index 790a50d7a..67f5b4aaf 100644
+--- a/db/db_impl/db_impl_debug.cc
++++ b/db/db_impl/db_impl_debug.cc
+@@ -9,6 +9,7 @@
+ 
+ #ifndef NDEBUG
+ 
++#include "db/blob/blob_file_cache.h"
+ #include "db/column_family.h"
+ #include "db/db_impl/db_impl.h"
+ #include "db/error_handler.h"
+@@ -328,5 +329,49 @@ size_t DBImpl::TEST_EstimateInMemoryStatsHistorySize() const {
+   InstrumentedMutexLock l(&const_cast<DBImpl*>(this)->stats_history_mutex_);
+   return EstimateInMemoryStatsHistorySize();
+ }
++
++void DBImpl::TEST_VerifyNoObsoleteFilesCached(
++    bool db_mutex_already_held) const {
++  // This check is somewhat expensive and obscure to make a part of every
++  // unit test in every build variety. Thus, we only enable it for ASAN builds.
++  if (!kMustFreeHeapAllocations) {
++    return;
++  }
++
++  std::optional<InstrumentedMutexLock> l;
++  if (db_mutex_already_held) {
++    mutex_.AssertHeld();
++  } else {
++    l.emplace(&mutex_);
++  }
++
++  std::vector<uint64_t> live_files;
++  for (auto cfd : *versions_->GetColumnFamilySet()) {
++    if (cfd->IsDropped()) {
++      continue;
++    }
++    // Sneakily add both SST and blob files to the same list
++    cfd->current()->AddLiveFiles(&live_files, &live_files);
++  }
++  std::sort(live_files.begin(), live_files.end());
++
++  auto fn = [&live_files](const Slice& key, Cache::ObjectPtr, size_t,
++                          const Cache::CacheItemHelper* helper) {
++    if (helper != BlobFileCache::GetHelper()) {
++      // Skip non-blob files for now
++      // FIXME: diagnose and fix the leaks of obsolete SST files revealed in
++      // unit tests.
++      return;
++    }
++    // See TableCache and BlobFileCache
++    assert(key.size() == sizeof(uint64_t));
++    uint64_t file_number;
++    GetUnaligned(reinterpret_cast<const uint64_t*>(key.data()), &file_number);
++    // Assert file is in sorted live_files
++    assert(
++        std::binary_search(live_files.begin(), live_files.end(), file_number));
++  };
++  table_cache_->ApplyToAllEntries(fn, {});
++}
+ }  // namespace ROCKSDB_NAMESPACE
+ #endif  // NDEBUG
+diff --git a/db/db_iter.cc b/db/db_iter.cc
+index e02586377..bf4749eb9 100644
+--- a/db/db_iter.cc
++++ b/db/db_iter.cc
+@@ -540,6 +540,8 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
+     } else {
+       iter_.Next();
+     }
++    // This could be a long-running operation due to tombstones, etc.
++    ROCKSDB_THREAD_YIELD_HOOK();
+   } while (iter_.Valid());
+ 
+   valid_ = false;
+diff --git a/db/table_cache.cc b/db/table_cache.cc
+index 71fc29c32..8a5be75e8 100644
+--- a/db/table_cache.cc
++++ b/db/table_cache.cc
+@@ -164,6 +164,7 @@ Status TableCache::GetTableReader(
+ }
+ 
+ Cache::Handle* TableCache::Lookup(Cache* cache, uint64_t file_number) {
++  // NOTE: sharing same Cache with BlobFileCache
+   Slice key = GetSliceForFileNumber(&file_number);
+   return cache->Lookup(key);
+ }
+@@ -179,6 +180,7 @@ Status TableCache::FindTable(
+     size_t max_file_size_for_l0_meta_pin, Temperature file_temperature) {
+   PERF_TIMER_GUARD_WITH_CLOCK(find_table_nanos, ioptions_.clock);
+   uint64_t number = file_meta.fd.GetNumber();
++  // NOTE: sharing same Cache with BlobFileCache
+   Slice key = GetSliceForFileNumber(&number);
+   *handle = cache_.Lookup(key);
+   TEST_SYNC_POINT_CALLBACK("TableCache::FindTable:0",
+diff --git a/db/version_builder.cc b/db/version_builder.cc
+index ed8ab8214..c98f53f42 100644
+--- a/db/version_builder.cc
++++ b/db/version_builder.cc
+@@ -24,6 +24,7 @@
+ #include <vector>
+ 
+ #include "cache/cache_reservation_manager.h"
++#include "db/blob/blob_file_cache.h"
+ #include "db/blob/blob_file_meta.h"
+ #include "db/dbformat.h"
+ #include "db/internal_stats.h"
+@@ -744,12 +745,9 @@ class VersionBuilder::Rep {
+       return Status::Corruption("VersionBuilder", oss.str());
+     }
+ 
+-    // Note: we use C++11 for now but in C++14, this could be done in a more
+-    // elegant way using generalized lambda capture.
+-    VersionSet* const vs = version_set_;
+-    const ImmutableCFOptions* const ioptions = ioptions_;
+-
+-    auto deleter = [vs, ioptions](SharedBlobFileMetaData* shared_meta) {
++    auto deleter = [vs = version_set_, ioptions = ioptions_,
++                    bc = cfd_ ? cfd_->blob_file_cache()
++                              : nullptr](SharedBlobFileMetaData* shared_meta) {
+       if (vs) {
+         assert(ioptions);
+         assert(!ioptions->cf_paths.empty());
+@@ -758,6 +756,9 @@ class VersionBuilder::Rep {
+         vs->AddObsoleteBlobFile(shared_meta->GetBlobFileNumber(),
+                                 ioptions->cf_paths.front().path);
+       }
++      if (bc) {
++        bc->Evict(shared_meta->GetBlobFileNumber());
++      }
+ 
+       delete shared_meta;
+     };
+@@ -766,7 +767,7 @@ class VersionBuilder::Rep {
+         blob_file_number, blob_file_addition.GetTotalBlobCount(),
+         blob_file_addition.GetTotalBlobBytes(),
+         blob_file_addition.GetChecksumMethod(),
+-        blob_file_addition.GetChecksumValue(), deleter);
++        blob_file_addition.GetChecksumValue(), std::move(deleter));
+ 
+     mutable_blob_file_metas_.emplace(
+         blob_file_number, MutableBlobFileMetaData(std::move(shared_meta)));
+diff --git a/db/version_set.h b/db/version_set.h
+index 9336782b1..024f869e7 100644
+--- a/db/version_set.h
++++ b/db/version_set.h
+@@ -1514,7 +1514,6 @@ class VersionSet {
+   void GetLiveFilesMetaData(std::vector<LiveFileMetaData>* metadata);
+ 
+   void AddObsoleteBlobFile(uint64_t blob_file_number, std::string path) {
+-    // TODO: Erase file from BlobFileCache?
+     obsolete_blob_files_.emplace_back(blob_file_number, std::move(path));
+   }
+ 
+diff --git a/include/rocksdb/version.h b/include/rocksdb/version.h
+index 2a19796b8..0afa2cab1 100644
+--- a/include/rocksdb/version.h
++++ b/include/rocksdb/version.h
+@@ -13,7 +13,7 @@
+ // minor or major version number planned for release.
+ #define ROCKSDB_MAJOR 9
+ #define ROCKSDB_MINOR 7
+-#define ROCKSDB_PATCH 3
++#define ROCKSDB_PATCH 4
+ 
+ // Do not use these. We made the mistake of declaring macros starting with
+ // double underscore. Now we have to live with our choice. We'll deprecate these
+diff --git a/port/port.h b/port/port.h
+index 13aa56d47..141716e5b 100644
+--- a/port/port.h
++++ b/port/port.h
+@@ -19,3 +19,19 @@
+ #elif defined(OS_WIN)
+ #include "port/win/port_win.h"
+ #endif
++
++#ifdef OS_LINUX
++// A temporary hook into long-running RocksDB threads to support modifying their
++// priority etc. This should become a public API hook once the requirements
++// are better understood.
++extern "C" void RocksDbThreadYield() __attribute__((__weak__));
++#define ROCKSDB_THREAD_YIELD_HOOK() \
++  {                                 \
++    if (RocksDbThreadYield) {       \
++      RocksDbThreadYield();         \
++    }                               \
++  }
++#else
++#define ROCKSDB_THREAD_YIELD_HOOK() \
++  {}
++#endif

external/rocksdb/patches/9.x.x-0001-exclude-thirdparty.patch

@@ -0,0 +1,30 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 93b884d..b715cb6 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -106,14 +106,9 @@ endif()
+ include(CMakeDependentOption)
+
+ if(MSVC)
+-  option(WITH_GFLAGS "build with GFlags" OFF)
+   option(WITH_XPRESS "build with windows built in compression" OFF)
+-  option(ROCKSDB_SKIP_THIRDPARTY "skip thirdparty.inc" OFF)
+-
+-  if(NOT ROCKSDB_SKIP_THIRDPARTY)
+-    include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
+-  endif()
+-else()
++endif()
++if(TRUE)
+   if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD" AND NOT CMAKE_SYSTEM_NAME MATCHES "kFreeBSD")
+     # FreeBSD has jemalloc as default malloc
+     # but it does not have all the jemalloc files in include/...
+@@ -126,7 +121,7 @@ else()
+     endif()
+   endif()
+
+-  if(MINGW)
++  if(MSVC OR MINGW)
+     option(WITH_GFLAGS "build with GFlags" OFF)
+   else()
+     option(WITH_GFLAGS "build with GFlags" ON)

external/soci/conanfile.py

@@ -70,7 +70,7 @@ class SociConan(ConanFile):
         if self.options.with_postgresql:
             self.requires("libpq/15.5")
         if self.options.with_boost:
-            self.requires("boost/1.86.0")
+            self.requires("boost/1.83.0")
 
     @property
     def _minimum_compilers_version(self):
@@ -154,7 +154,7 @@ class SociConan(ConanFile):
         self.cpp_info.components["soci_core"].set_property("cmake_target_name", "SOCI::soci_core{}".format(target_suffix))
         self.cpp_info.components["soci_core"].libs = ["{}soci_core{}".format(lib_prefix, lib_suffix)]
         if self.options.with_boost:
-            self.cpp_info.components["soci_core"].requires.append("boost::headers")
+            self.cpp_info.components["soci_core"].requires.append("boost::boost")
 
         # soci_empty
         if self.options.empty:

external/wamr/conandata.yml

@@ -0,0 +1,6 @@
+patches:
+  2.3.1:
+  - patch_description: add metering to iwasm interpreter
+    patch_file: patches/ripp_metering.patch
+    patch_type: conan
+

external/wamr/conanfile.py

@@ -0,0 +1,92 @@
+from conans import ConanFile, tools
+from conan.tools.cmake import CMake, CMakeToolchain, CMakeDeps, cmake_layout
+from conan.tools.files import (
+    apply_conandata_patches,
+    export_conandata_patches,
+    # get,
+)
+
+# import os
+
+required_conan_version = ">=1.55.0"
+
+
+class WamrConan(ConanFile):
+    name = "wamr"
+    version = "2.3.1"
+    license = "Apache License v2.0"
+    url = "https://github.com/bytecodealliance/wasm-micro-runtime.git"
+    description = "Webassembly micro runtime"
+    package_type = "library"
+    settings = "os", "compiler", "build_type", "arch"
+    options = {"shared": [True, False], "fPIC": [True, False]}
+    default_options = {"shared": False, "fPIC": True}
+    generators = "CMakeToolchain", "CMakeDeps"
+    # requires = [("llvm/20.1.1@")]
+
+    def export_sources(self):
+        export_conandata_patches(self)
+        pass
+
+    # def build_requirements(self):
+    #    self.tool_requires("llvm/20.1.1")
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            del self.options.fPIC
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
+    def source(self):
+        git = tools.Git()
+        git.clone(
+            "https://github.com/bytecodealliance/wasm-micro-runtime.git",
+            "2a303861cc916dc182b7fecaa0aacc1b797e7ac6",
+            shallow=True,
+        )
+        # get(self, **self.conan_data["sources"][self.version], strip_root=True)
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+
+        tc.variables["WAMR_BUILD_INTERP"] = 1
+        tc.variables["WAMR_BUILD_FAST_INTERP"] = 1
+        tc.variables["WAMR_BUILD_INSTRUCTION_METERING"] = 1
+        tc.variables["WAMR_BUILD_AOT"] = 0
+        tc.variables["WAMR_BUILD_JIT"] = 0
+        tc.variables["WAMR_BUILD_FAST_JIT"] = 0
+        tc.variables["WAMR_DISABLE_HW_BOUND_CHECK"] = 1
+        tc.variables["WAMR_DISABLE_STACK_HW_BOUND_CHECK"] = 1
+        tc.variables["WAMR_BH_LOG"] = "wamr_log_to_rippled"
+        # tc.variables["WAMR_BUILD_FAST_JIT"] = 0 if self.settings.os == "Windows" else 1
+        # ll_dep = self.dependencies["llvm"]
+        # self.output.info(f"-----------package_folder: {type(ll_dep.__dict__)}")
+        # tc.variables["LLVM_DIR"] = os.path.join(ll_dep.package_folder, "lib", "cmake", "llvm")
+        tc.generate()
+
+        # This generates "foo-config.cmake" and "bar-config.cmake" in self.generators_folder
+        deps = CMakeDeps(self)
+        deps.generate()
+
+    def build(self):
+        apply_conandata_patches(self)
+        cmake = CMake(self)
+        cmake.verbose = True
+        cmake.configure()
+        cmake.build()
+        # self.run(f'echo {self.source_folder}')
+        # Explicit way:
+        # self.run('cmake %s/hello %s' % (self.source_folder, cmake.command_line))
+        # self.run("cmake --build . %s" % cmake.build_config)
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.verbose = True
+        cmake.install()
+
+    def package_info(self):
+        self.cpp_info.libs = ["iwasm"]
+        self.cpp_info.names["cmake_find_package"] = "wamr"
+        self.cpp_info.names["cmake_find_package_multi"] = "wamr"
+

external/wamr/patches/ripp_metering.patch

@@ -0,0 +1,724 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 88a1642b..aeb29912 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -1,7 +1,7 @@
+ # Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ 
+-cmake_minimum_required (VERSION 3.14)
++cmake_minimum_required (VERSION 3.20)
+ 
+ option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)
+ 
+diff --git a/core/iwasm/aot/aot_runtime.c b/core/iwasm/aot/aot_runtime.c
+index b2c9ed62..87947a18 100644
+--- a/core/iwasm/aot/aot_runtime.c
++++ b/core/iwasm/aot/aot_runtime.c
+@@ -5484,7 +5484,7 @@ aot_resolve_import_func(AOTModule *module, AOTImportFunc *import_func)
+     import_func->func_ptr_linked = wasm_native_resolve_symbol(
+         import_func->module_name, import_func->func_name,
+         import_func->func_type, &import_func->signature,
+-        &import_func->attachment, &import_func->call_conv_raw);
++        &import_func->attachment, NULL, &import_func->call_conv_raw);
+ #if WASM_ENABLE_MULTI_MODULE != 0
+     if (!import_func->func_ptr_linked) {
+         if (!wasm_runtime_is_built_in_module(import_func->module_name)) {
+diff --git a/core/iwasm/common/wasm_c_api.c b/core/iwasm/common/wasm_c_api.c
+index 269ec577..34eb7c34 100644
+--- a/core/iwasm/common/wasm_c_api.c
++++ b/core/iwasm/common/wasm_c_api.c
+@@ -3242,10 +3242,20 @@ wasm_func_copy(const wasm_func_t *func)
+ 
+     cloned->func_idx_rt = func->func_idx_rt;
+     cloned->inst_comm_rt = func->inst_comm_rt;
++    cloned->gas = func->gas;
+ 
+     RETURN_OBJ(cloned, wasm_func_delete)
+ }
+ 
++uint32_t
++wasm_func_set_gas(wasm_func_t *func, uint32_t gas)
++{
++    if(!func) return 0;
++
++    func->gas = gas;
++    return gas;
++}
++
+ own wasm_functype_t *
+ wasm_func_type(const wasm_func_t *func)
+ {
+@@ -4998,11 +5008,11 @@ wasm_instance_new_with_args_ex(wasm_store_t *store, const wasm_module_t *module,
+         goto failed;
+     }
+ 
++    WASMModuleInstance *wasm_module_inst = NULL;
+     /* create the c-api func import list */
+ #if WASM_ENABLE_INTERP != 0
+     if (instance->inst_comm_rt->module_type == Wasm_Module_Bytecode) {
+-        WASMModuleInstance *wasm_module_inst =
+-            (WASMModuleInstance *)instance->inst_comm_rt;
++        wasm_module_inst = (WASMModuleInstance *)instance->inst_comm_rt;
+         p_func_imports = &(wasm_module_inst->c_api_func_imports);
+         import_func_count = MODULE_INTERP(module)->import_function_count;
+     }
+@@ -5052,6 +5062,13 @@ wasm_instance_new_with_args_ex(wasm_store_t *store, const wasm_module_t *module,
+         }
+         bh_assert(func_import->func_ptr_linked);
+ 
++        // fill gas
++        if(wasm_module_inst) {
++            WASMFunctionInstance *fi = wasm_module_inst->e->functions + func_host->func_idx_rt;
++            if(fi) fi->gas = func_host->gas;
++        }
++
++
+         func_import++;
+     }
+ 
+@@ -5389,3 +5406,8 @@ wasm_instance_get_wasm_func_exec_time(const wasm_instance_t *instance,
+     return -1.0;
+ #endif
+ }
++
++wasm_exec_env_t wasm_instance_exec_env(const wasm_instance_t *instance)
++{
++    return wasm_runtime_get_exec_env_singleton(instance->inst_comm_rt);
++}
+diff --git a/core/iwasm/common/wasm_c_api_internal.h b/core/iwasm/common/wasm_c_api_internal.h
+index 49a17a96..19a85980 100644
+--- a/core/iwasm/common/wasm_c_api_internal.h
++++ b/core/iwasm/common/wasm_c_api_internal.h
+@@ -142,6 +142,10 @@ struct wasm_func_t {
+             void (*finalizer)(void *);
+         } cb_env;
+     } u;
++
++    // gas cost for import func
++    uint32 gas;
++
+     /*
+      * an index in both functions runtime instance lists
+      * of interpreter mode and aot mode
+diff --git a/core/iwasm/common/wasm_exec_env.c b/core/iwasm/common/wasm_exec_env.c
+index 47752950..d5821c4f 100644
+--- a/core/iwasm/common/wasm_exec_env.c
++++ b/core/iwasm/common/wasm_exec_env.c
+@@ -86,7 +86,9 @@ wasm_exec_env_create_internal(struct WASMModuleInstanceCommon *module_inst,
+ #endif
+ 
+ #if WASM_ENABLE_INSTRUCTION_METERING != 0
+-    exec_env->instructions_to_execute = -1;
++    exec_env->instructions_to_execute = INT64_MAX;
++    for(int i = 0; i < 256; ++i)
++        exec_env->instructions_schedule[i] = 1;
+ #endif
+ 
+     return exec_env;
+diff --git a/core/iwasm/common/wasm_exec_env.h b/core/iwasm/common/wasm_exec_env.h
+index 5d80312f..2713a092 100644
+--- a/core/iwasm/common/wasm_exec_env.h
++++ b/core/iwasm/common/wasm_exec_env.h
+@@ -89,7 +89,8 @@ typedef struct WASMExecEnv {
+ 
+ #if WASM_ENABLE_INSTRUCTION_METERING != 0
+     /* instructions to execute */
+-    int instructions_to_execute;
++    int64 instructions_to_execute;
++    int64 instructions_schedule[256];
+ #endif
+ 
+ #if WASM_ENABLE_FAST_JIT != 0
+diff --git a/core/iwasm/common/wasm_native.c b/core/iwasm/common/wasm_native.c
+index 060bb2c3..9221c36a 100644
+--- a/core/iwasm/common/wasm_native.c
++++ b/core/iwasm/common/wasm_native.c
+@@ -180,9 +180,9 @@ native_symbol_cmp(const void *native_symbol1, const void *native_symbol2)
+                   ((const NativeSymbol *)native_symbol2)->symbol);
+ }
+ 
+-static void *
++static NativeSymbol *
+ lookup_symbol(NativeSymbol *native_symbols, uint32 n_native_symbols,
+-              const char *symbol, const char **p_signature, void **p_attachment)
++              const char *symbol)
+ {
+     NativeSymbol *native_symbol, key = { 0 };
+ 
+@@ -190,9 +190,7 @@ lookup_symbol(NativeSymbol *native_symbols, uint32 n_native_symbols,
+ 
+     if ((native_symbol = bsearch(&key, native_symbols, n_native_symbols,
+                                  sizeof(NativeSymbol), native_symbol_cmp))) {
+-        *p_signature = native_symbol->signature;
+-        *p_attachment = native_symbol->attachment;
+-        return native_symbol->func_ptr;
++        return native_symbol;
+     }
+ 
+     return NULL;
+@@ -205,25 +203,36 @@ lookup_symbol(NativeSymbol *native_symbols, uint32 n_native_symbols,
+ void *
+ wasm_native_resolve_symbol(const char *module_name, const char *field_name,
+                            const WASMFuncType *func_type,
+-                           const char **p_signature, void **p_attachment,
++                           const char **p_signature, void **p_attachment, uint32_t *gas,
+                            bool *p_call_conv_raw)
+ {
+     NativeSymbolsNode *node, *node_next;
+     const char *signature = NULL;
+     void *func_ptr = NULL, *attachment = NULL;
++    NativeSymbol *native_symbol = NULL;
+ 
+     node = g_native_symbols_list;
+     while (node) {
+         node_next = node->next;
+         if (!strcmp(node->module_name, module_name)) {
+-            if ((func_ptr =
++            if ((native_symbol =
+                      lookup_symbol(node->native_symbols, node->n_native_symbols,
+-                                   field_name, &signature, &attachment))
++                                   field_name))
+                 || (field_name[0] == '_'
+-                    && (func_ptr = lookup_symbol(
++                    && (native_symbol = lookup_symbol(
+                             node->native_symbols, node->n_native_symbols,
+-                            field_name + 1, &signature, &attachment))))
+-                break;
++                            field_name + 1))))
++            {
++                func_ptr = native_symbol->func_ptr;
++                if(func_ptr)
++                {
++                    if(gas)
++                        *gas = native_symbol->gas;
++                    signature = native_symbol->signature;
++                    attachment = native_symbol->attachment;
++                    break;
++                }
++            }
+         }
+         node = node_next;
+     }
+diff --git a/core/iwasm/common/wasm_native.h b/core/iwasm/common/wasm_native.h
+index 9a6afee1..0fe4739f 100644
+--- a/core/iwasm/common/wasm_native.h
++++ b/core/iwasm/common/wasm_native.h
+@@ -52,7 +52,7 @@ wasm_native_lookup_libc_builtin_global(const char *module_name,
+ void *
+ wasm_native_resolve_symbol(const char *module_name, const char *field_name,
+                            const WASMFuncType *func_type,
+-                           const char **p_signature, void **p_attachment,
++                           const char **p_signature, void **p_attachment, uint32_t *gas,
+                            bool *p_call_conv_raw);
+ 
+ bool
+diff --git a/core/iwasm/common/wasm_runtime_common.c b/core/iwasm/common/wasm_runtime_common.c
+index dcee0aea..10c516d6 100644
+--- a/core/iwasm/common/wasm_runtime_common.c
++++ b/core/iwasm/common/wasm_runtime_common.c
+@@ -2288,10 +2288,26 @@ wasm_runtime_access_exce_check_guard_page()
+ #if WASM_ENABLE_INSTRUCTION_METERING != 0
+ void
+ wasm_runtime_set_instruction_count_limit(WASMExecEnv *exec_env,
+-                                         int instructions_to_execute)
++                                         int64 instructions_to_execute)
+ {
++    if(instructions_to_execute == -1)
++        instructions_to_execute = INT64_MAX;
+     exec_env->instructions_to_execute = instructions_to_execute;
+ }
++
++int64
++wasm_runtime_get_instruction_count_limit(WASMExecEnv *exec_env)
++{
++    return exec_env->instructions_to_execute;
++}
++
++void
++wasm_runtime_set_instruction_schedule(WASMExecEnv *exec_env,
++                                         int64 const *instructions_schedule)
++{
++    for(int i = 0; i < 256; ++i)
++        exec_env->instructions_schedule[i] = instructions_schedule[i];
++}
+ #endif
+ 
+ WASMFuncType *
+@@ -7348,7 +7364,7 @@ wasm_runtime_is_import_func_linked(const char *module_name,
+                                    const char *func_name)
+ {
+     return wasm_native_resolve_symbol(module_name, func_name, NULL, NULL, NULL,
+-                                      NULL);
++                                      NULL, NULL);
+ }
+ 
+ bool
+@@ -7805,13 +7821,14 @@ wasm_runtime_get_module_name(wasm_module_t module)
+ bool
+ wasm_runtime_detect_native_stack_overflow(WASMExecEnv *exec_env)
+ {
++#if WASM_DISABLE_STACK_HW_BOUND_CHECK == 0
+     uint8 *boundary = exec_env->native_stack_boundary;
+     RECORD_STACK_USAGE(exec_env, (uint8 *)&boundary);
+     if (boundary == NULL) {
+         /* the platform doesn't support os_thread_get_stack_boundary */
+         return true;
+     }
+-#if defined(OS_ENABLE_HW_BOUND_CHECK) && WASM_DISABLE_STACK_HW_BOUND_CHECK == 0
++#if defined(OS_ENABLE_HW_BOUND_CHECK)
+     uint32 page_size = os_getpagesize();
+     uint32 guard_page_count = STACK_OVERFLOW_CHECK_GUARD_PAGE_COUNT;
+     boundary = boundary + page_size * guard_page_count;
+@@ -7821,6 +7838,7 @@ wasm_runtime_detect_native_stack_overflow(WASMExecEnv *exec_env)
+                                    "native stack overflow");
+         return false;
+     }
++#endif
+     return true;
+ }
+ 
+@@ -7843,7 +7861,7 @@ wasm_runtime_detect_native_stack_overflow_size(WASMExecEnv *exec_env,
+     boundary = boundary - WASM_STACK_GUARD_SIZE + requested_size;
+     if ((uint8 *)&boundary < boundary) {
+         wasm_runtime_set_exception(wasm_runtime_get_module_inst(exec_env),
+-                                   "native stack overflow");
++                                   "native s stack overflow");
+         return false;
+     }
+     return true;
+diff --git a/core/iwasm/common/wasm_runtime_common.h b/core/iwasm/common/wasm_runtime_common.h
+index 64a6cd79..f4c55e2f 100644
+--- a/core/iwasm/common/wasm_runtime_common.h
++++ b/core/iwasm/common/wasm_runtime_common.h
+@@ -795,7 +795,14 @@ wasm_runtime_set_native_stack_boundary(WASMExecEnv *exec_env,
+ /* See wasm_export.h for description */
+ WASM_RUNTIME_API_EXTERN void
+ wasm_runtime_set_instruction_count_limit(WASMExecEnv *exec_env,
+-                                         int instructions_to_execute);
++                                         int64 instructions_to_execute);
++WASM_RUNTIME_API_EXTERN int64
++wasm_runtime_get_instruction_count_limit(WASMExecEnv *exec_env);
++
++WASM_RUNTIME_API_EXTERN void
++wasm_runtime_set_instruction_schedule(WASMExecEnv *exec_env,
++                                      int64 const *instructions_schedule);
++
+ #endif
+ 
+ #if WASM_CONFIGURABLE_BOUNDS_CHECKS != 0
+diff --git a/core/iwasm/include/lib_export.h b/core/iwasm/include/lib_export.h
+index 0ca668f5..93bcf807 100644
+--- a/core/iwasm/include/lib_export.h
++++ b/core/iwasm/include/lib_export.h
+@@ -24,6 +24,8 @@ typedef struct NativeSymbol {
+     /* attachment which can be retrieved in native API by
+        calling wasm_runtime_get_function_attachment(exec_env) */
+     void *attachment;
++    // gas cost for import func
++    uint32_t gas;
+ } NativeSymbol;
+ 
+ /* clang-format off */
+diff --git a/core/iwasm/include/wasm_c_api.h b/core/iwasm/include/wasm_c_api.h
+index 241a0eec..1141744c 100644
+--- a/core/iwasm/include/wasm_c_api.h
++++ b/core/iwasm/include/wasm_c_api.h
+@@ -19,8 +19,10 @@
+ #if defined(_MSC_BUILD)
+ #if defined(COMPILING_WASM_RUNTIME_API)
+ #define WASM_API_EXTERN __declspec(dllexport)
+-#else
++#elif defined(_DLL)
+ #define WASM_API_EXTERN __declspec(dllimport)
++#else
++#define WASM_API_EXTERN
+ #endif
+ #else
+ #define WASM_API_EXTERN
+@@ -592,6 +594,8 @@ WASM_API_EXTERN size_t wasm_func_result_arity(const wasm_func_t*);
+ WASM_API_EXTERN own wasm_trap_t* wasm_func_call(
+   const wasm_func_t*, const wasm_val_vec_t* args, wasm_val_vec_t* results);
+ 
++WASM_API_EXTERN own uint32_t wasm_func_set_gas(wasm_func_t*, uint32_t);
++
+ 
+ // Global Instances
+ 
+@@ -701,6 +705,11 @@ WASM_API_EXTERN double wasm_instance_sum_wasm_exec_time(const wasm_instance_t*);
+ // func_name. If the function is not found, return 0.
+ WASM_API_EXTERN double wasm_instance_get_wasm_func_exec_time(const wasm_instance_t*, const char *);
+ 
++struct WASMExecEnv;
++typedef struct WASMExecEnv *wasm_exec_env_t;
++
++WASM_API_EXTERN wasm_exec_env_t wasm_instance_exec_env(const wasm_instance_t*);
++
+ ///////////////////////////////////////////////////////////////////////////////
+ // Convenience
+ 
+diff --git a/core/iwasm/include/wasm_export.h b/core/iwasm/include/wasm_export.h
+index b4ab34be..3fd0949f 100644
+--- a/core/iwasm/include/wasm_export.h
++++ b/core/iwasm/include/wasm_export.h
+@@ -20,8 +20,10 @@
+ #if defined(_MSC_BUILD)
+ #if defined(COMPILING_WASM_RUNTIME_API)
+ #define WASM_RUNTIME_API_EXTERN __declspec(dllexport)
+-#else
++#elif defined(_DLL)
+ #define WASM_RUNTIME_API_EXTERN __declspec(dllimport)
++#else
++#define WASM_RUNTIME_API_EXTERN
+ #endif
+ #elif defined(__GNUC__) || defined(__clang__)
+ #define WASM_RUNTIME_API_EXTERN __attribute__((visibility("default")))
+@@ -1833,7 +1835,14 @@ wasm_runtime_set_native_stack_boundary(wasm_exec_env_t exec_env,
+  */
+ WASM_RUNTIME_API_EXTERN void
+ wasm_runtime_set_instruction_count_limit(wasm_exec_env_t exec_env,
+-                                         int instruction_count);
++                                         int64_t instruction_count);
++
++WASM_RUNTIME_API_EXTERN int64_t
++wasm_runtime_get_instruction_count_limit(wasm_exec_env_t exec_env);
++
++WASM_RUNTIME_API_EXTERN void
++wasm_runtime_set_instruction_schedule(wasm_exec_env_t exec_env,
++                                      int64_t const *instructions_schedule);
+ 
+ /**
+  * Dump runtime memory consumption, including:
+diff --git a/core/iwasm/interpreter/wasm.h b/core/iwasm/interpreter/wasm.h
+index ddc0b15b..3a707878 100644
+--- a/core/iwasm/interpreter/wasm.h
++++ b/core/iwasm/interpreter/wasm.h
+@@ -579,6 +579,9 @@ typedef struct WASMFunctionImport {
+     WASMModule *import_module;
+     WASMFunction *import_func_linked;
+ #endif
++    // gas cost for import func
++    uint32 gas;
++
+ } WASMFunctionImport;
+ 
+ #if WASM_ENABLE_TAGS != 0
+diff --git a/core/iwasm/interpreter/wasm_interp_classic.c b/core/iwasm/interpreter/wasm_interp_classic.c
+index 1e98b0fa..ae24ff8b 100644
+--- a/core/iwasm/interpreter/wasm_interp_classic.c
++++ b/core/iwasm/interpreter/wasm_interp_classic.c
+@@ -1569,13 +1569,14 @@ get_global_addr(uint8 *global_data, WASMGlobalInstance *global)
+ }
+ 
+ #if WASM_ENABLE_INSTRUCTION_METERING != 0
+-#define CHECK_INSTRUCTION_LIMIT()                                 \
+-    if (instructions_left == 0) {                                 \
+-        wasm_set_exception(module, "instruction limit exceeded"); \
+-        goto got_exception;                                       \
+-    }                                                             \
+-    else if (instructions_left > 0)                               \
+-        instructions_left--;
++#define CHECK_INSTRUCTION_LIMIT()                                     \
++    do {                                                              \
++        instructions_left -= instructions_schedule[opcode];           \
++        if (instructions_left < 0) {                                  \
++            wasm_set_exception(module, "instruction limit exceeded"); \
++            goto got_exception;                                       \
++        }                                                             \
++    } while (0)
+ #else
+ #define CHECK_INSTRUCTION_LIMIT() (void)0
+ #endif
+@@ -1625,9 +1626,11 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
+     uint32 cache_index, type_index, param_cell_num, cell_num;
+ 
+ #if WASM_ENABLE_INSTRUCTION_METERING != 0
+-    int instructions_left = -1;
++    int64 instructions_left = INT64_MAX;
++    int64 const *instructions_schedule = NULL;
+     if (exec_env) {
+         instructions_left = exec_env->instructions_to_execute;
++        instructions_schedule = exec_env->instructions_schedule;
+     }
+ #endif
+ 
+@@ -6885,6 +6888,11 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
+         FREE_FRAME(exec_env, frame);
+         wasm_exec_env_set_cur_frame(exec_env, prev_frame);
+ 
++#if WASM_ENABLE_INSTRUCTION_METERING != 0
++        if(exec_env)
++            exec_env->instructions_to_execute = instructions_left;
++#endif
++
+         if (!prev_frame->ip) {
+             /* Called from native. */
+             return;
+@@ -6925,6 +6933,12 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
+         }
+ #endif
+         SYNC_ALL_TO_FRAME();
++
++#if WASM_ENABLE_INSTRUCTION_METERING != 0
++        if(exec_env)
++            exec_env->instructions_to_execute = instructions_left;
++#endif
++
+         return;
+ 
+ #if WASM_ENABLE_LABELS_AS_VALUES == 0
+diff --git a/core/iwasm/interpreter/wasm_interp_fast.c b/core/iwasm/interpreter/wasm_interp_fast.c
+index 4e5edf41..04c39e1f 100644
+--- a/core/iwasm/interpreter/wasm_interp_fast.c
++++ b/core/iwasm/interpreter/wasm_interp_fast.c
+@@ -106,14 +106,14 @@ typedef float64 CellType_F64;
+     } while (0)
+ 
+ #if WASM_ENABLE_INSTRUCTION_METERING != 0
+-#define CHECK_INSTRUCTION_LIMIT()                                 \
+-    if (instructions_left == 0) {                                 \
+-        wasm_set_exception(module, "instruction limit exceeded"); \
+-        goto got_exception;                                       \
+-    }                                                             \
+-    else if (instructions_left > 0)                               \
+-        instructions_left--;
+-
++#define CHECK_INSTRUCTION_LIMIT()                                     \
++    do {                                                              \
++        instructions_left -= instructions_schedule[opcode];           \
++        if (instructions_left < 0) {                                  \
++            wasm_set_exception(module, "instruction limit exceeded"); \
++            goto got_exception;                                       \
++        }                                                             \
++    } while (0)
+ #else
+ #define CHECK_INSTRUCTION_LIMIT() (void)0
+ #endif
+@@ -1454,7 +1454,6 @@ wasm_interp_dump_op_count()
+     do {                                               \
+         const void *p_label_addr = *(void **)frame_ip; \
+         frame_ip += sizeof(void *);                    \
+-        CHECK_INSTRUCTION_LIMIT();                     \
+         goto *p_label_addr;                            \
+     } while (0)
+ #else
+@@ -1466,7 +1465,6 @@ wasm_interp_dump_op_count()
+         /* int32 relative offset was emitted in 64-bit target */          \
+         p_label_addr = label_base + (int32)LOAD_U32_WITH_2U16S(frame_ip); \
+         frame_ip += sizeof(int32);                                        \
+-        CHECK_INSTRUCTION_LIMIT();                                        \
+         goto *p_label_addr;                                               \
+     } while (0)
+ #else
+@@ -1477,17 +1475,18 @@ wasm_interp_dump_op_count()
+         /* uint32 label address was emitted in 32-bit target */          \
+         p_label_addr = (void *)(uintptr_t)LOAD_U32_WITH_2U16S(frame_ip); \
+         frame_ip += sizeof(int32);                                       \
+-        CHECK_INSTRUCTION_LIMIT();                                       \
+         goto *p_label_addr;                                              \
+     } while (0)
+ #endif
+ #endif /* end of WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS */
+-#define HANDLE_OP_END() FETCH_OPCODE_AND_DISPATCH()
++#define HANDLE_OP_END() CHECK_INSTRUCTION_LIMIT(); FETCH_OPCODE_AND_DISPATCH()
+ 
+ #else /* else of WASM_ENABLE_LABELS_AS_VALUES */
+ 
+ #define HANDLE_OP(opcode) case opcode:
+-#define HANDLE_OP_END() continue
++#define HANDLE_OP_END()        \
++    CHECK_INSTRUCTION_LIMIT(); \
++    continue
+ 
+ #endif /* end of WASM_ENABLE_LABELS_AS_VALUES */
+ 
+@@ -1508,6 +1507,25 @@ get_global_addr(uint8 *global_data, WASMGlobalInstance *global)
+ #endif
+ }
+ 
++static int64 const def_instructions_schedule[256] = {
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
++    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
++};
++
+ static void
+ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
+                                WASMExecEnv *exec_env,
+@@ -1556,9 +1574,11 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
+     uint8 opcode = 0, local_type, *global_addr;
+ 
+ #if WASM_ENABLE_INSTRUCTION_METERING != 0
+-    int instructions_left = -1;
++    int64 instructions_left = INT64_MAX;
++    int64 const *instructions_schedule = def_instructions_schedule;
+     if (exec_env) {
+         instructions_left = exec_env->instructions_to_execute;
++        instructions_schedule = exec_env->instructions_schedule;
+     }
+ #endif
+ #if !defined(OS_ENABLE_HW_BOUND_CHECK) \
+@@ -7694,6 +7714,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
+             {
+                 wasm_interp_call_func_native(module, exec_env, cur_func,
+                                              prev_frame);
++                instructions_left -= cur_func->gas;
+             }
+ 
+ #if WASM_ENABLE_TAIL_CALL != 0 || WASM_ENABLE_GC != 0
+@@ -7806,6 +7827,11 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
+         FREE_FRAME(exec_env, frame);
+         wasm_exec_env_set_cur_frame(exec_env, (WASMRuntimeFrame *)prev_frame);
+ 
++#if WASM_ENABLE_INSTRUCTION_METERING != 0
++        if (exec_env)
++            exec_env->instructions_to_execute = instructions_left;
++#endif
++
+         if (!prev_frame->ip)
+             /* Called from native. */
+             return;
+@@ -7834,6 +7860,10 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
+ 
+     got_exception:
+         SYNC_ALL_TO_FRAME();
++#if WASM_ENABLE_INSTRUCTION_METERING != 0
++        if (exec_env)
++            exec_env->instructions_to_execute = instructions_left;
++#endif
+         return;
+ 
+ #if WASM_ENABLE_LABELS_AS_VALUES == 0
+diff --git a/core/iwasm/interpreter/wasm_mini_loader.c b/core/iwasm/interpreter/wasm_mini_loader.c
+index e66c08ba..d52e677e 100644
+--- a/core/iwasm/interpreter/wasm_mini_loader.c
++++ b/core/iwasm/interpreter/wasm_mini_loader.c
+@@ -636,6 +636,7 @@ load_function_import(const uint8 **p_buf, const uint8 *buf_end,
+     const char *linked_signature = NULL;
+     void *linked_attachment = NULL;
+     bool linked_call_conv_raw = false;
++    uint32_t gas = 0;
+ 
+     read_leb_uint32(p, p_end, declare_type_index);
+     *p_buf = p;
+@@ -647,7 +648,7 @@ load_function_import(const uint8 **p_buf, const uint8 *buf_end,
+     /* check built-in modules */
+     linked_func = wasm_native_resolve_symbol(
+         sub_module_name, function_name, declare_func_type, &linked_signature,
+-        &linked_attachment, &linked_call_conv_raw);
++        &linked_attachment, &gas, &linked_call_conv_raw);
+ 
+     function->module_name = (char *)sub_module_name;
+     function->field_name = (char *)function_name;
+@@ -656,6 +657,7 @@ load_function_import(const uint8 **p_buf, const uint8 *buf_end,
+     function->signature = linked_signature;
+     function->attachment = linked_attachment;
+     function->call_conv_raw = linked_call_conv_raw;
++    function->gas = gas;
+     return true;
+ }
+ 
+diff --git a/core/iwasm/interpreter/wasm_runtime.c b/core/iwasm/interpreter/wasm_runtime.c
+index 3cc2afe0..55859d35 100644
+--- a/core/iwasm/interpreter/wasm_runtime.c
++++ b/core/iwasm/interpreter/wasm_runtime.c
+@@ -168,7 +168,7 @@ wasm_resolve_import_func(const WASMModule *module, WASMFunctionImport *function)
+ #endif
+     function->func_ptr_linked = wasm_native_resolve_symbol(
+         function->module_name, function->field_name, function->func_type,
+-        &function->signature, &function->attachment, &function->call_conv_raw);
++        &function->signature, &function->attachment, &function->gas, &function->call_conv_raw);
+ 
+     if (function->func_ptr_linked) {
+         return true;
+@@ -820,6 +820,7 @@ functions_instantiate(const WASMModule *module, WASMModuleInstance *module_inst,
+         function->param_count =
+             (uint16)function->u.func_import->func_type->param_count;
+         function->param_types = function->u.func_import->func_type->types;
++        function->gas = import->u.function.gas;
+         function->local_cell_num = 0;
+         function->local_count = 0;
+         function->local_types = NULL;
+diff --git a/core/iwasm/interpreter/wasm_runtime.h b/core/iwasm/interpreter/wasm_runtime.h
+index 8d38c883..a687ab89 100644
+--- a/core/iwasm/interpreter/wasm_runtime.h
++++ b/core/iwasm/interpreter/wasm_runtime.h
+@@ -228,6 +228,10 @@ struct WASMFunctionInstance {
+         WASMFunctionImport *func_import;
+         WASMFunction *func;
+     } u;
++
++    // gas cost for import func
++    uint32 gas;
++
+ #if WASM_ENABLE_MULTI_MODULE != 0
+     WASMModuleInstance *import_module_inst;
+     WASMFunctionInstance *import_func_inst;
+diff --git a/core/iwasm/libraries/libc-builtin/libc_builtin_wrapper.c b/core/iwasm/libraries/libc-builtin/libc_builtin_wrapper.c
+index a68c0749..cafb6915 100644
+--- a/core/iwasm/libraries/libc-builtin/libc_builtin_wrapper.c
++++ b/core/iwasm/libraries/libc-builtin/libc_builtin_wrapper.c
+@@ -1038,16 +1038,16 @@ print_f64_wrapper(wasm_exec_env_t exec_env, double f64)
+ 
+ /* clang-format off */
+ #define REG_NATIVE_FUNC(func_name, signature) \
+-    { #func_name, func_name##_wrapper, signature, NULL }
++    { #func_name, func_name##_wrapper, signature, NULL, 0 }
+ /* clang-format on */
+ 
+ static NativeSymbol native_symbols_libc_builtin[] = {
+     REG_NATIVE_FUNC(printf, "($*)i"),
+     REG_NATIVE_FUNC(sprintf, "($$*)i"),
+     REG_NATIVE_FUNC(snprintf, "(*~$*)i"),
+-    { "vprintf", printf_wrapper, "($*)i", NULL },
+-    { "vsprintf", sprintf_wrapper, "($$*)i", NULL },
+-    { "vsnprintf", snprintf_wrapper, "(*~$*)i", NULL },
++    { "vprintf", printf_wrapper, "($*)i", NULL, 0 },
++    { "vsprintf", sprintf_wrapper, "($$*)i", NULL, 0 },
++    { "vsnprintf", snprintf_wrapper, "(*~$*)i", NULL, 0 },
+     REG_NATIVE_FUNC(puts, "($)i"),
+     REG_NATIVE_FUNC(putchar, "(i)i"),
+     REG_NATIVE_FUNC(memcmp, "(**~)i"),
+diff --git a/core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c b/core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c
+index 6d057a6a..25879f33 100644
+--- a/core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c
++++ b/core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c
+@@ -2257,7 +2257,7 @@ wasi_sched_yield(wasm_exec_env_t exec_env)
+ 
+ /* clang-format off */
+ #define REG_NATIVE_FUNC(func_name, signature) \
+-    { #func_name, wasi_##func_name, signature, NULL }
++    { #func_name, wasi_##func_name, signature, NULL, 0 }
+ /* clang-format on */
+ 
+ static NativeSymbol native_symbols_libc_wasi[] = {
+diff --git a/core/shared/platform/include/platform_wasi_types.h b/core/shared/platform/include/platform_wasi_types.h
+index ac1a95ea..e23b500e 100644
+--- a/core/shared/platform/include/platform_wasi_types.h
++++ b/core/shared/platform/include/platform_wasi_types.h
+@@ -36,7 +36,11 @@ extern "C" {
+ #if WASM_ENABLE_UVWASI != 0 || WASM_ENABLE_LIBC_WASI == 0
+ #define assert_wasi_layout(expr, message) /* nothing */
+ #else
+-#define assert_wasi_layout(expr, message) _Static_assert(expr, message)
++    #ifndef _MSC_VER
++        #define assert_wasi_layout(expr, message) _Static_assert(expr, message)
++    #else
++        #define assert_wasi_layout(expr, message) static_assert(expr, message)
++    #endif
+ #endif
+ 
+ assert_wasi_layout(_Alignof(int8_t) == 1, "non-wasi data layout");

include/xrpl/basics/Buffer.h

@@ -25,7 +25,6 @@
 
 #include <cstdint>
 #include <cstring>
-#include <memory>
 
 namespace ripple {
 

include/xrpl/basics/Expected.h

@@ -22,18 +22,8 @@
 
 #include <xrpl/basics/contract.h>
 
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated"
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
 #include <boost/outcome.hpp>
 
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
 #include <stdexcept>
 
 namespace ripple {

include/xrpl/basics/Log.h

@@ -26,7 +26,6 @@
 #include <boost/beast/core/string.hpp>
 #include <boost/filesystem.hpp>
 
-#include <fstream>
 #include <map>
 #include <memory>
 #include <mutex>

include/xrpl/basics/StringUtilities.h

@@ -29,6 +29,7 @@
 #include <array>
 #include <cstdint>
 #include <optional>
+#include <sstream>
 #include <string>
 
 namespace ripple {

include/xrpl/basics/TaggedCache.h

@@ -37,28 +37,6 @@
 
 namespace ripple {
 
-namespace detail {
-template <typename T>
-constexpr bool IsStatelessLambdaV = std::is_empty_v<T> && std::is_constructible_v<T>;
-
-template<class Lambda, int=(Lambda{}(), 0)>
-constexpr std::true_type IsConstexpr(Lambda);
-constexpr std::false_type IsConstexpr(...);
-
-template <typename T>
-constexpr bool IsConstexprInvocableV = IsStatelessLambdaV<T> && decltype(IsConstexpr(T{})){};
-
-template <typename Lambda, bool ConstInvocable = IsConstexprInvocableV<Lambda>>
-constexpr bool ShouldTakeConstReferenceV = false;
-
-template <typename Lambda>
-constexpr bool ShouldTakeConstReferenceV<Lambda, true> = Lambda{}();
-
-template <typename Lambda>
-constexpr bool ShouldTakeConstReferenceV<Lambda, false> = true;
-
-}
-
 /** Map/cache combination.
     This class implements a cache and a map. The cache keeps objects alive
     in the map. The map allows multiple code paths that reference objects
@@ -140,15 +118,6 @@ public:
     del(key_type const& key, bool valid);
 
 public:
-
-    // We take a const reference if R (the replaceCallback) is a stateless
-    // lambda and can be evaluated at compile time, and it's evaluated to true,
-    // because there's no chance to update the parameter.
-    template <class R>
-    using SharedPointerTypeReference = std::conditional_t<
-        detail::ShouldTakeConstReferenceV<R>,
-        SharedPointerType const&,
-        SharedPointerType&>;
     /** Replace aliased objects with originals.
 
         Due to concurrency it is possible for two separate objects with
@@ -158,7 +127,7 @@ public:
 
         @param key The key corresponding to the object
         @param data A shared pointer to the data corresponding to the object.
-        @param replaceCallback Function that decides if cache should be replaced
+        @param replace Function that decides if cache should be replaced
 
         @return `true` If the key already existed.
     */
@@ -166,7 +135,7 @@ public:
     bool
     canonicalize(
         key_type const& key,
-        SharedPointerTypeReference<R> data,
+        SharedPointerType& data,
         R&& replaceCallback);
 
     bool

include/xrpl/basics/TaggedCache.ipp

@@ -415,7 +415,7 @@ TaggedCache<
     Mutex>::
     canonicalize(
         key_type const& key,
-        SharedPointerTypeReference<R> data,
+        SharedPointerType& data,
         R&& replaceCallback)
 {
     // Return canonical value, store if needed, refresh in cache
@@ -457,7 +457,7 @@ TaggedCache<
         {
             entry.ptr = data;
         }
-        else if constexpr (std::assignable_from<decltype(data), decltype(entry.ptr.getStrong())>)
+        else
         {
             data = entry.ptr.getStrong();
         }
@@ -473,7 +473,7 @@ TaggedCache<
         {
             entry.ptr = data;
         }
-        else if constexpr (std::assignable_from<decltype(data), decltype(entry.ptr.getStrong())>)
+        else
         {
             entry.ptr.convertToStrong();
             data = cachedData;
@@ -513,7 +513,7 @@ TaggedCache<
         SharedPointerType const& data)
 {
     return canonicalize(
-        key, data, []() { return true; });
+        key, const_cast<SharedPointerType&>(data), []() { return true; });
 }
 
 template <

include/xrpl/basics/algorithm.h

@@ -20,6 +20,7 @@
 #ifndef RIPPLE_ALGORITHM_H_INCLUDED
 #define RIPPLE_ALGORITHM_H_INCLUDED
 
+#include <iterator>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/hardened_hash.h

@@ -24,8 +24,12 @@
 #include <xrpl/beast/hash/xxhasher.h>
 
 #include <cstdint>
+#include <functional>
 #include <mutex>
 #include <random>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/mulDiv.h

@@ -23,6 +23,7 @@
 #include <cstdint>
 #include <limits>
 #include <optional>
+#include <utility>
 
 namespace ripple {
 auto constexpr muldiv_max = std::numeric_limits<std::uint64_t>::max();

include/xrpl/basics/tagged_integer.h

@@ -24,8 +24,10 @@
 
 #include <boost/operators.hpp>
 
+#include <functional>
 #include <iostream>
 #include <type_traits>
+#include <utility>
 
 namespace ripple {
 

include/xrpl/beast/clock/abstract_clock.h

@@ -20,6 +20,9 @@
 #ifndef BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
 #define BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
 
+#include <chrono>
+#include <string>
+
 namespace beast {
 
 /** Abstract interface to a clock.

include/xrpl/beast/clock/manual_clock.h

@@ -23,8 +23,6 @@
 #include <xrpl/beast/clock/abstract_clock.h>
 #include <xrpl/beast/utility/instrumentation.h>
 
-#include <chrono>
-
 namespace beast {
 
 /** Manual clock implementation.

include/xrpl/beast/container/aged_container_utility.h

@@ -22,7 +22,6 @@
 
 #include <xrpl/beast/container/aged_container.h>
 
-#include <chrono>
 #include <type_traits>
 
 namespace beast {

include/xrpl/beast/container/detail/aged_associative_container.h

@@ -20,6 +20,8 @@
 #ifndef BEAST_CONTAINER_DETAIL_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
 #define BEAST_CONTAINER_DETAIL_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
 
+#include <type_traits>
+
 namespace beast {
 namespace detail {
 

include/xrpl/beast/container/detail/aged_ordered_container.h

@@ -33,6 +33,7 @@
 #include <algorithm>
 #include <functional>
 #include <initializer_list>
+#include <iterator>
 #include <memory>
 #include <type_traits>
 #include <utility>

include/xrpl/beast/container/detail/aged_unordered_container.h

@@ -3257,6 +3257,7 @@ operator==(aged_unordered_container<
 {
     if (size() != other.size())
         return false;
+    using EqRng = std::pair<const_iterator, const_iterator>;
     for (auto iter(cbegin()), last(cend()); iter != last;)
     {
         auto const& k(extract(*iter));

include/xrpl/beast/core/LexicalCast.h

@@ -29,9 +29,11 @@
 #include <charconv>
 #include <cstdlib>
 #include <iterator>
+#include <limits>
 #include <string>
 #include <type_traits>
 #include <typeinfo>
+#include <utility>
 
 namespace beast {
 

include/xrpl/beast/hash/hash_append.h

@@ -24,36 +24,14 @@
 #include <boost/container/flat_set.hpp>
 #include <boost/endian/conversion.hpp>
 
-/*
-
-Workaround for overzealous clang warning, which trips on libstdc++ headers
-
-  In file included from
-  /usr/lib/gcc/x86_64-linux-gnu/12/../../../../include/c++/12/bits/stl_algo.h:61:
-  /usr/lib/gcc/x86_64-linux-gnu/12/../../../../include/c++/12/bits/stl_tempbuf.h:263:8:
-  error: 'get_temporary_buffer<std::pair<ripple::Quality, const
-  std::vector<std::unique_ptr<ripple::Step>> *>>' is deprecated
-  [-Werror,-Wdeprecated-declarations] 263 |
-  std::get_temporary_buffer<value_type>(_M_original_len));
-       ^
-*/
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated"
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <functional>
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
 #include <array>
 #include <chrono>
+#include <cstdint>
 #include <cstring>
+#include <functional>
+#include <map>
 #include <memory>
+#include <set>
 #include <string>
 #include <system_error>
 #include <tuple>

include/xrpl/beast/net/IPAddress.h

@@ -29,7 +29,11 @@
 #include <boost/asio/ip/address.hpp>
 #include <boost/functional/hash.hpp>
 
+#include <cstdint>
+#include <ios>
+#include <sstream>
 #include <string>
+#include <typeinfo>
 
 //------------------------------------------------------------------------------
 

include/xrpl/beast/net/IPAddressV4.h

@@ -24,6 +24,12 @@
 
 #include <boost/asio/ip/address_v4.hpp>
 
+#include <cstdint>
+#include <functional>
+#include <ios>
+#include <string>
+#include <utility>
+
 namespace beast {
 namespace IP {
 

include/xrpl/beast/net/IPAddressV6.h

@@ -24,6 +24,12 @@
 
 #include <boost/asio/ip/address_v6.hpp>
 
+#include <cstdint>
+#include <functional>
+#include <ios>
+#include <string>
+#include <utility>
+
 namespace beast {
 namespace IP {
 

include/xrpl/beast/net/IPEndpoint.h

@@ -25,6 +25,7 @@
 #include <xrpl/beast/net/IPAddress.h>
 
 #include <cstdint>
+#include <ios>
 #include <optional>
 #include <string>
 

include/xrpl/beast/rfc2616.h

@@ -28,8 +28,10 @@
 
 #include <algorithm>
 #include <cctype>
+#include <cstdint>
 #include <iterator>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace beast {

include/xrpl/beast/test/yield_to.h

@@ -13,6 +13,7 @@
 #include <boost/optional.hpp>
 
 #include <condition_variable>
+#include <functional>
 #include <mutex>
 #include <thread>
 #include <vector>

include/xrpl/beast/unit_test/reporter.h

@@ -16,6 +16,7 @@
 
 #include <algorithm>
 #include <chrono>
+#include <functional>
 #include <iomanip>
 #include <iostream>
 #include <sstream>

include/xrpl/beast/unit_test/runner.h

@@ -13,6 +13,7 @@
 #include <boost/assert.hpp>
 
 #include <mutex>
+#include <ostream>
 #include <string>
 
 namespace beast {

include/xrpl/beast/utility/rngfill.h

@@ -31,28 +31,36 @@ namespace beast {
 
 template <class Generator>
 void
-rngfill(void* const buffer, std::size_t const bytes, Generator& g)
+rngfill(void* buffer, std::size_t bytes, Generator& g)
 {
     using result_type = typename Generator::result_type;
-    constexpr std::size_t result_size = sizeof(result_type);
 
-    std::uint8_t* const buffer_start = static_cast<std::uint8_t*>(buffer);
-    std::size_t const complete_iterations = bytes / result_size;
-    std::size_t const bytes_remaining = bytes % result_size;
-
-    for (std::size_t count = 0; count < complete_iterations; ++count)
+    while (bytes >= sizeof(result_type))
     {
-        result_type const v = g();
-        std::size_t const offset = count * result_size;
-        std::memcpy(buffer_start + offset, &v, result_size);
+        auto const v = g();
+        std::memcpy(buffer, &v, sizeof(v));
+        buffer = reinterpret_cast<std::uint8_t*>(buffer) + sizeof(v);
+        bytes -= sizeof(v);
     }
 
-    if (bytes_remaining > 0)
+    XRPL_ASSERT(
+        bytes < sizeof(result_type), "beast::rngfill(void*) : maximum bytes");
+
+#ifdef __GNUC__
+    // gcc 11.1 (falsely) warns about an array-bounds overflow in release mode.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#endif
+
+    if (bytes > 0)
     {
-        result_type const v = g();
-        std::size_t const offset = complete_iterations * result_size;
-        std::memcpy(buffer_start + offset, &v, bytes_remaining);
+        auto const v = g();
+        std::memcpy(buffer, &v, bytes);
     }
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 }
 
 template <

include/xrpl/json/json_value.h

@@ -26,6 +26,7 @@
 #include <cstring>
 #include <map>
 #include <string>
+#include <utility>
 #include <vector>
 
 /** \brief JSON (JavaScript Object Notation).

include/xrpl/protocol/AccountID.h

@@ -29,6 +29,7 @@
 #include <xrpl/protocol/json_get_or_throw.h>
 
 #include <cstddef>
+#include <mutex>
 #include <optional>
 #include <string>
 

include/xrpl/protocol/ApiVersion.h

@@ -20,6 +20,7 @@
 #ifndef RIPPLE_PROTOCOL_APIVERSION_H_INCLUDED
 #define RIPPLE_PROTOCOL_APIVERSION_H_INCLUDED
 
+#include <functional>
 #include <type_traits>
 #include <utility>
 

include/xrpl/protocol/ErrorCodes.h

@@ -169,8 +169,6 @@ enum warning_code_i {
     warnRPC_AMENDMENT_BLOCKED = 1002,
     warnRPC_EXPIRED_VALIDATOR_LIST = 1003,
     // unused = 1004
-    warnRPC_FIELDS_DEPRECATED = 2004,  // rippled needs to maintain
-                                       // compatibility with Clio on this code.
 };
 
 //------------------------------------------------------------------------------

include/xrpl/protocol/Feature.h

@@ -24,6 +24,7 @@
 
 #include <boost/container/flat_map.hpp>
 
+#include <array>
 #include <bitset>
 #include <map>
 #include <optional>
@@ -53,19 +54,19 @@
  *    then change the macro parameter in features.macro to
  *    `VoteBehavior::DefaultYes`. The communication process is beyond
  *    the scope of these instructions.
-
- * 5) If a supported feature (`Supported::yes`) was _ever_ in a released
- *     version, it can never be changed back to `Supported::no`, because
- *     it _may_ still become enabled at any time. This would cause newer
- *     versions of `rippled` to become amendment blocked.
- *     Instead, to prevent newer versions from voting on the feature, use
- *     `VoteBehavior::Obsolete`. Obsolete features can not be voted for
- *     by any versions of `rippled` built with that setting, but will still
- *     work correctly if they get enabled. If a feature remains obsolete
- *     for long enough that _all_ clients that could vote for it are
- *     amendment blocked, the feature can be removed from the code
- *     as if it was unsupported.
  *
+ * 5) A feature marked as Obsolete can mean either:
+ *    1) It is in the ledger (marked as Supported::yes) and it is on its way to
+ *      become Retired
+ *    2) The feature is not in the ledger (has always been marked as
+ *      Supported::no) and the code to support it has been removed
+ *
+ * If we want to discontinue a feature that we've never fully supported and
+ * the feature has never been enabled, we should remove all the related
+ * code, and mark the feature as "abandoned". To do this:
+ *
+ * 1) Open features.macro, move the feature to the abandoned section and
+ *    change the macro to XRPL_ABANDON
  *
  * When a feature has been enabled for several years, the conditional code
  * may be removed, and the feature "retired". To retire a feature:
@@ -99,10 +100,13 @@ namespace detail {
 #undef XRPL_FIX
 #pragma push_macro("XRPL_RETIRE")
 #undef XRPL_RETIRE
+#pragma push_macro("XRPL_ABANDON")
+#undef XRPL_ABANDON
 
 #define XRPL_FEATURE(name, supported, vote) +1
 #define XRPL_FIX(name, supported, vote) +1
 #define XRPL_RETIRE(name) +1
+#define XRPL_ABANDON(name) +1
 
 // This value SHOULD be equal to the number of amendments registered in
 // Feature.cpp. Because it's only used to reserve storage, and determine how
@@ -119,6 +123,8 @@ static constexpr std::size_t numFeatures =
 #pragma pop_macro("XRPL_FIX")
 #undef XRPL_FEATURE
 #pragma pop_macro("XRPL_FEATURE")
+#undef XRPL_ABANDON
+#pragma pop_macro("XRPL_ABANDON")
 
 /** Amendments that this server supports and the default voting behavior.
    Whether they are enabled depends on the Rules defined in the validated
@@ -360,10 +366,13 @@ foreachFeature(FeatureBitset bs, F&& f)
 #undef XRPL_FIX
 #pragma push_macro("XRPL_RETIRE")
 #undef XRPL_RETIRE
+#pragma push_macro("XRPL_ABANDON")
+#undef XRPL_ABANDON
 
 #define XRPL_FEATURE(name, supported, vote) extern uint256 const feature##name;
 #define XRPL_FIX(name, supported, vote) extern uint256 const fix##name;
 #define XRPL_RETIRE(name)
+#define XRPL_ABANDON(name)
 
 #include <xrpl/protocol/detail/features.macro>
 
@@ -373,6 +382,8 @@ foreachFeature(FeatureBitset bs, F&& f)
 #pragma pop_macro("XRPL_FIX")
 #undef XRPL_FEATURE
 #pragma pop_macro("XRPL_FEATURE")
+#undef XRPL_ABANDON
+#pragma pop_macro("XRPL_ABANDON")
 
 }  // namespace ripple
 

include/xrpl/protocol/FeeUnits.h

@@ -27,9 +27,14 @@
 #include <boost/multiprecision/cpp_int.hpp>
 #include <boost/operators.hpp>
 
+#include <cmath>
+#include <ios>
 #include <iosfwd>
 #include <limits>
 #include <optional>
+#include <sstream>
+#include <string>
+#include <utility>
 
 namespace ripple {
 
@@ -446,8 +451,8 @@ mulDivU(Source1 value, Dest mul, Source2 div)
     }
 
     using namespace boost::multiprecision;
-
-    uint128_t product;
+    using uint128 = boost::multiprecision::uint128_t;
+    uint128 product;
     product = multiply(
         product,
         static_cast<std::uint64_t>(value.value()),

include/xrpl/protocol/Fees.h

@@ -24,6 +24,8 @@
 
 namespace ripple {
 
+constexpr std::uint32_t MICRO_DROPS_PER_DROP{1'000'000};
+
 /** Reflects the fee settings for a particular ledger.
 
     The fees are always the same for any transactions applied
@@ -34,6 +36,10 @@ struct Fees
     XRPAmount base{0};       // Reference tx cost (drops)
     XRPAmount reserve{0};    // Reserve base (drops)
     XRPAmount increment{0};  // Reserve increment (drops)
+    std::uint32_t extensionComputeLimit{
+        0};  // Extension compute limit (instructions)
+    std::uint32_t extensionSizeLimit{0};  // Extension size limit (bytes)
+    std::uint32_t gasPrice{0};            // price of WASM gas (micro-drops)
 
     explicit Fees() = default;
     Fees(Fees const&) = default;

include/xrpl/protocol/Indexes.h

@@ -32,7 +32,6 @@
 #include <xrpl/protocol/jss.h>
 
 #include <cstdint>
-#include <set>
 
 namespace ripple {
 
@@ -231,6 +230,12 @@ page(Keylet const& root, std::uint64_t index = 0) noexcept
 Keylet
 escrow(AccountID const& src, std::uint32_t seq) noexcept;
 
+inline Keylet
+escrow(uint256 const& key) noexcept
+{
+    return {ltESCROW, key};
+}
+
 /** A PaymentChannel */
 Keylet
 payChan(AccountID const& src, AccountID const& dst, std::uint32_t seq) noexcept;

include/xrpl/protocol/Issue.h

@@ -24,6 +24,9 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/UintTypes.h>
 
+#include <functional>
+#include <type_traits>
+
 namespace ripple {
 
 /** A currency issued by an account.

include/xrpl/protocol/MPTAmount.h

@@ -149,11 +149,12 @@ mulRatio(
     bool roundUp)
 {
     using namespace boost::multiprecision;
+    using int128 = boost::multiprecision::int128_t;
 
     if (!den)
         Throw<std::runtime_error>("division by zero");
 
-    int128_t const amt128(amt.value());
+    int128 const amt128(amt.value());
     auto const neg = amt.value() < 0;
     auto const m = amt128 * num;
     auto r = m / den;

include/xrpl/protocol/MultiApiJson.h

@@ -28,6 +28,7 @@
 #include <concepts>
 #include <cstdlib>
 #include <functional>
+#include <limits>
 #include <type_traits>
 #include <utility>
 

include/xrpl/protocol/Permissions.h

@@ -25,6 +25,7 @@
 #include <optional>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 
 namespace ripple {
 /**

include/xrpl/protocol/Protocol.h

@@ -126,6 +126,10 @@ std::uint8_t constexpr vaultStrategyFirstComeFirstServe = 1;
  * another vault; counted from 0 */
 std::uint8_t constexpr maxAssetCheckDepth = 5;
 
+/** The maximum length of a Data field in Escrow object that can be updated by
+ * Wasm code */
+std::size_t constexpr maxWasmDataLength = 4 * 1024;
+
 /** A ledger index. */
 using LedgerIndex = std::uint32_t;
 

include/xrpl/protocol/PublicKey.h

@@ -32,6 +32,7 @@
 #include <cstring>
 #include <optional>
 #include <ostream>
+#include <utility>
 
 namespace ripple {
 

include/xrpl/protocol/SOTemplate.h

@@ -25,6 +25,7 @@
 
 #include <functional>
 #include <initializer_list>
+#include <memory>
 #include <stdexcept>
 
 namespace ripple {

include/xrpl/protocol/STBase.h

@@ -24,6 +24,7 @@
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/Serializer.h>
 
+#include <memory>
 #include <ostream>
 #include <string>
 #include <type_traits>

include/xrpl/protocol/STBlob.h

@@ -27,6 +27,7 @@
 #include <xrpl/protocol/STBase.h>
 
 #include <cstring>
+#include <memory>
 
 namespace ripple {
 

include/xrpl/protocol/STValidation.h

@@ -28,6 +28,8 @@
 #include <xrpl/protocol/SecretKey.h>
 
 #include <cstdint>
+#include <functional>
+#include <memory>
 #include <optional>
 #include <sstream>
 

include/xrpl/protocol/Serializer.h

@@ -33,6 +33,7 @@
 
 #include <cstdint>
 #include <cstring>
+#include <iomanip>
 #include <type_traits>
 
 namespace ripple {

include/xrpl/protocol/Sign.h

@@ -25,6 +25,8 @@
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/SecretKey.h>
 
+#include <utility>
+
 namespace ripple {
 
 /** Sign an STObject

include/xrpl/protocol/TER.h

@@ -141,6 +141,8 @@ enum TEMcodes : TERUnderlyingType {
     temARRAY_TOO_LARGE,
     temBAD_TRANSFER_FEE,
     temINVALID_INNER_BATCH,
+
+    temBAD_WASM,
 };
 
 //------------------------------------------------------------------------------
@@ -185,6 +187,8 @@ enum TEFcodes : TERUnderlyingType {
     tefNO_TICKET,
     tefNFTOKEN_IS_NOT_TRANSFERABLE,
     tefINVALID_LEDGER_FIX_TYPE,
+    tefNO_WASM,
+    tefWASM_FIELD_NOT_INCLUDED,
 };
 
 //------------------------------------------------------------------------------
@@ -362,6 +366,7 @@ enum TECcodes : TERUnderlyingType {
     tecPSEUDO_ACCOUNT = 196,
     tecPRECISION_LOSS = 197,
     tecNO_DELEGATE_PERMISSION = 198,
+    tecWASM_REJECTED = 199,
 };
 
 //------------------------------------------------------------------------------

include/xrpl/protocol/TxMeta.h

@@ -46,10 +46,7 @@ private:
         CtorHelper);
 
 public:
-    TxMeta(
-        uint256 const& transactionID,
-        std::uint32_t ledger,
-        std::optional<uint256> parentBatchId = std::nullopt);
+    TxMeta(uint256 const& transactionID, std::uint32_t ledger);
     TxMeta(uint256 const& txID, std::uint32_t ledger, Blob const&);
     TxMeta(uint256 const& txID, std::uint32_t ledger, std::string const&);
     TxMeta(uint256 const& txID, std::uint32_t ledger, STObject const&);
@@ -136,7 +133,7 @@ public:
     void
     setParentBatchId(uint256 const& parentBatchId)
     {
-        mParentBatchId = parentBatchId;
+        parentBatchId_ = parentBatchId;
     }
 
     uint256
@@ -145,13 +142,33 @@ public:
         XRPL_ASSERT(
             hasParentBatchId(),
             "ripple::TxMeta::getParentBatchId : non-null batch id");
-        return *mParentBatchId;
+        return *parentBatchId_;
     }
 
     bool
     hasParentBatchId() const
     {
-        return static_cast<bool>(mParentBatchId);
+        return static_cast<bool>(parentBatchId_);
+    }
+
+    void
+    setGasUsed(std::uint32_t const& gasUsed)
+    {
+        gasUsed_ = gasUsed;
+    }
+
+    std::uint32_t
+    getGasUsed() const
+    {
+        XRPL_ASSERT(
+            hasGasUsed(), "ripple::TxMeta::getGasUsed : non-null batch id");
+        return *gasUsed_;
+    }
+
+    bool
+    hasGasUsed() const
+    {
+        return static_cast<bool>(gasUsed_);
     }
 
 private:
@@ -161,7 +178,8 @@ private:
     int mResult;
 
     std::optional<STAmount> mDelivered;
-    std::optional<uint256> mParentBatchId;
+    std::optional<std::uint32_t> gasUsed_;
+    std::optional<uint256> parentBatchId_;
 
     STArray mNodes;
 };

include/xrpl/protocol/XChainAttestations.h

@@ -35,6 +35,8 @@
 #include <boost/container/vector.hpp>
 
 #include <cstddef>
+#include <type_traits>
+#include <unordered_map>
 #include <vector>
 
 namespace ripple {

include/xrpl/protocol/XRPAmount.h

@@ -286,11 +286,12 @@ mulRatio(
     bool roundUp)
 {
     using namespace boost::multiprecision;
+    using int128 = boost::multiprecision::int128_t;
 
     if (!den)
         Throw<std::runtime_error>("division by zero");
 
-    int128_t const amt128(amt.drops());
+    int128 const amt128(amt.drops());
     auto const neg = amt.drops() < 0;
     auto const m = amt128 * num;
     auto r = m / den;

include/xrpl/protocol/detail/b58_utils.h

@@ -27,6 +27,7 @@
 #include <boost/outcome.hpp>
 #include <boost/outcome/result.hpp>
 
+#include <cinttypes>
 #include <span>
 #include <system_error>
 #include <tuple>

include/xrpl/protocol/detail/features.macro

@@ -26,14 +26,16 @@
 #if !defined(XRPL_RETIRE)
 #error "undefined macro: XRPL_RETIRE"
 #endif
+#if !defined(XRPL_ABANDON)
+#error "undefined macro: XRPL_ABANDON"
+#endif
 
 // Add new amendments to the top of this list.
 // Keep it sorted in reverse chronological order.
 // If you add an amendment here, then do not forget to increment `numFeatures`
 // in include/xrpl/protocol/Feature.h.
 
-XRPL_FIX    (MPTDeliveredAmount,         Supported::no,  VoteBehavior::DefaultNo)
-XRPL_FIX    (AMMClawbackRounding,        Supported::no,  VoteBehavior::DefaultNo)
+XRPL_FEATURE(SmartEscrow,                Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(TokenEscrow,                Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (EnforceNFTokenTrustlineV2,  Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (AMMv1_3,                    Supported::yes, VoteBehavior::DefaultNo)
@@ -42,7 +44,6 @@ XRPL_FEATURE(Batch,                      Supported::yes, VoteBehavior::DefaultNo
 XRPL_FEATURE(SingleAssetVault,           Supported::no, VoteBehavior::DefaultNo)
 XRPL_FEATURE(PermissionDelegation,       Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (PayChanCancelAfter,         Supported::yes, VoteBehavior::DefaultNo)
-// Check flags in Credential transactions
 XRPL_FIX    (InvalidTxFlags,             Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (FrozenLPTokenTransfer,      Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(DeepFreeze,                 Supported::yes, VoteBehavior::DefaultNo)
@@ -96,6 +97,7 @@ XRPL_FEATURE(HardenedValidations,        Supported::yes, VoteBehavior::DefaultYe
 // fix1781: XRPEndpointSteps should be included in the circular payment check
 XRPL_FIX    (1781,                       Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(RequireFullyCanonicalSig,   Supported::yes, VoteBehavior::DefaultYes)
+// fixQualityUpperBound should be activated before FlowCross
 XRPL_FIX    (QualityUpperBound,          Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(DeletableAccounts,          Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FIX    (PayChanRecipientOwnerDir,   Supported::yes, VoteBehavior::DefaultYes)
@@ -113,6 +115,7 @@ XRPL_FIX    (1571,                       Supported::yes, VoteBehavior::DefaultYe
 XRPL_FEATURE(Checks,                     Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(DepositAuth,                Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FIX    (1513,                       Supported::yes, VoteBehavior::DefaultYes)
+XRPL_FEATURE(FlowCross,                  Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(Flow,                       Supported::yes, VoteBehavior::DefaultYes)
 
 // The following amendments are obsolete, but must remain supported
@@ -131,6 +134,11 @@ XRPL_FIX    (NFTokenDirV1,          Supported::yes, VoteBehavior::Obsolete)
 XRPL_FEATURE(NonFungibleTokensV1,   Supported::yes, VoteBehavior::Obsolete)
 XRPL_FEATURE(CryptoConditionsSuite, Supported::yes, VoteBehavior::Obsolete)
 
+// The following amendments were never supported, never enabled, and 
+// we've abanded them. These features should never be in the ledger,
+// and we've removed all the related code.
+XRPL_ABANDON(OwnerPaysFee)
+
 // The following amendments have been active for at least two years. Their
 // pre-amendment code has been removed and the identifiers are deprecated.
 // All known amendments and amendments that may appear in a validated
@@ -150,4 +158,3 @@ XRPL_RETIRE(fix1201)
 XRPL_RETIRE(fix1512)
 XRPL_RETIRE(fix1523)
 XRPL_RETIRE(fix1528)
-XRPL_RETIRE(FlowCross)

include/xrpl/protocol/detail/ledger_entries.macro

@@ -319,6 +319,12 @@ LEDGER_ENTRY(ltFEE_SETTINGS, 0x0073, FeeSettings, fee, ({
     {sfBaseFeeDrops,           soeOPTIONAL},
     {sfReserveBaseDrops,       soeOPTIONAL},
     {sfReserveIncrementDrops,  soeOPTIONAL},
+
+    // New fields
+    {sfExtensionComputeLimit,  soeOPTIONAL},
+    {sfExtensionSizeLimit,     soeOPTIONAL},
+    {sfGasPrice,               soeOPTIONAL},
+
     {sfPreviousTxnID,          soeOPTIONAL},
     {sfPreviousTxnLgrSeq,      soeOPTIONAL},
 }))
@@ -348,6 +354,8 @@ LEDGER_ENTRY(ltESCROW, 0x0075, Escrow, escrow, ({
     {sfCondition,            soeOPTIONAL},
     {sfCancelAfter,          soeOPTIONAL},
     {sfFinishAfter,          soeOPTIONAL},
+    {sfFinishFunction,       soeOPTIONAL},
+    {sfData,                 soeOPTIONAL},
     {sfSourceTag,            soeOPTIONAL},
     {sfDestinationTag,       soeOPTIONAL},
     {sfOwnerNode,            soeREQUIRED},
@@ -482,7 +490,8 @@ LEDGER_ENTRY(ltDELEGATE, 0x0083, Delegate, delegate, ({
 }))
 
 /** A ledger object representing a single asset vault.
-    \sa keylet::vault
+
+    \sa keylet::mptoken
  */
 LEDGER_ENTRY(ltVAULT, 0x0084, Vault, vault, ({
     {sfPreviousTxnID,        soeREQUIRED},

include/xrpl/protocol/detail/sfields.macro

@@ -114,6 +114,11 @@ TYPED_SFIELD(sfVoteWeight,               UINT32,    48)
 TYPED_SFIELD(sfFirstNFTokenSequence,     UINT32,    50)
 TYPED_SFIELD(sfOracleDocumentID,         UINT32,    51)
 TYPED_SFIELD(sfPermissionValue,          UINT32,    52)
+TYPED_SFIELD(sfExtensionComputeLimit,    UINT32,    53)
+TYPED_SFIELD(sfExtensionSizeLimit,       UINT32,    54)
+TYPED_SFIELD(sfGasPrice,                 UINT32,    55)
+TYPED_SFIELD(sfComputationAllowance,     UINT32,    56)
+TYPED_SFIELD(sfGasUsed,                  UINT32,    57)
 
 // 64-bit integers (common)
 TYPED_SFIELD(sfIndexNext,                UINT64,     1)
@@ -233,7 +238,7 @@ TYPED_SFIELD(sfBaseFeeDrops,             AMOUNT,    22)
 TYPED_SFIELD(sfReserveBaseDrops,         AMOUNT,    23)
 TYPED_SFIELD(sfReserveIncrementDrops,    AMOUNT,    24)
 
-// currency amount (AMM)
+// currency amount (more)
 TYPED_SFIELD(sfLPTokenOut,               AMOUNT,    25)
 TYPED_SFIELD(sfLPTokenIn,                AMOUNT,    26)
 TYPED_SFIELD(sfEPrice,                   AMOUNT,    27)
@@ -275,6 +280,7 @@ TYPED_SFIELD(sfAssetClass,               VL,        28)
 TYPED_SFIELD(sfProvider,                 VL,        29)
 TYPED_SFIELD(sfMPTokenMetadata,          VL,        30)
 TYPED_SFIELD(sfCredentialType,           VL,        31)
+TYPED_SFIELD(sfFinishFunction,           VL,        32)
 
 // account (common)
 TYPED_SFIELD(sfAccount,                  ACCOUNT,    1)

include/xrpl/protocol/detail/transactions.macro

@@ -44,11 +44,13 @@ TRANSACTION(ttPAYMENT, 0, Payment, Delegation::delegatable, ({
 /** This transaction type creates an escrow object. */
 TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate, Delegation::delegatable, ({
     {sfDestination, soeREQUIRED},
+    {sfDestinationTag, soeOPTIONAL},
     {sfAmount, soeREQUIRED, soeMPTSupported},
     {sfCondition, soeOPTIONAL},
     {sfCancelAfter, soeOPTIONAL},
     {sfFinishAfter, soeOPTIONAL},
-    {sfDestinationTag, soeOPTIONAL},
+    {sfFinishFunction, soeOPTIONAL},
+    {sfData,           soeOPTIONAL},
 }))
 
 /** This transaction type completes an existing escrow. */
@@ -58,6 +60,7 @@ TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish, Delegation::delegatable, ({
     {sfFulfillment, soeOPTIONAL},
     {sfCondition, soeOPTIONAL},
     {sfCredentialIDs, soeOPTIONAL},
+    {sfComputationAllowance, soeOPTIONAL},
 }))
 
 
@@ -409,7 +412,6 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate, Delegation::de
     {sfTransferFee, soeOPTIONAL},
     {sfMaximumAmount, soeOPTIONAL},
     {sfMPTokenMetadata, soeOPTIONAL},
-    {sfDomainID, soeOPTIONAL},
 }))
 
 /** This transaction type destroys a MPTokensIssuance instance */
@@ -421,7 +423,6 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy, Delegation::
 TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet, Delegation::delegatable, ({
     {sfMPTokenIssuanceID, soeREQUIRED},
     {sfHolder, soeOPTIONAL},
-    {sfDomainID, soeOPTIONAL},
 }))
 
 /** This transaction type authorizes a MPToken instance */
@@ -480,7 +481,7 @@ TRANSACTION(ttVAULT_CREATE, 65, VaultCreate, Delegation::delegatable, ({
     {sfAsset, soeREQUIRED, soeMPTSupported},
     {sfAssetsMaximum, soeOPTIONAL},
     {sfMPTokenMetadata, soeOPTIONAL},
-    {sfDomainID, soeOPTIONAL},
+    {sfDomainID, soeOPTIONAL}, // PermissionedDomainID
     {sfWithdrawalPolicy, soeOPTIONAL},
     {sfData, soeOPTIONAL},
 }))
@@ -489,7 +490,7 @@ TRANSACTION(ttVAULT_CREATE, 65, VaultCreate, Delegation::delegatable, ({
 TRANSACTION(ttVAULT_SET, 66, VaultSet, Delegation::delegatable, ({
     {sfVaultID, soeREQUIRED},
     {sfAssetsMaximum, soeOPTIONAL},
-    {sfDomainID, soeOPTIONAL},
+    {sfDomainID, soeOPTIONAL}, // PermissionedDomainID
     {sfData, soeOPTIONAL},
 }))
 
@@ -509,7 +510,6 @@ TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw, Delegation::delegatable, ({
     {sfVaultID, soeREQUIRED},
     {sfAmount, soeREQUIRED, soeMPTSupported},
     {sfDestination, soeOPTIONAL},
-    {sfDestinationTag, soeOPTIONAL},
 }))
 
 /** This transaction claws back tokens from a vault. */
@@ -548,6 +548,9 @@ TRANSACTION(ttFEE, 101, SetFee, Delegation::notDelegatable, ({
     {sfBaseFeeDrops, soeOPTIONAL},
     {sfReserveBaseDrops, soeOPTIONAL},
     {sfReserveIncrementDrops, soeOPTIONAL},
+    {sfExtensionComputeLimit, soeOPTIONAL},
+    {sfExtensionSizeLimit, soeOPTIONAL},
+    {sfGasPrice, soeOPTIONAL},
 }))
 
 /** This system-generated transaction type is used to update the network's negative UNL

include/xrpl/protocol/digest.h

@@ -25,6 +25,7 @@
 
 #include <boost/endian/conversion.hpp>
 
+#include <algorithm>
 #include <array>
 
 namespace ripple {

include/xrpl/protocol/json_get_or_throw.h

@@ -10,6 +10,7 @@
 #include <charconv>
 #include <exception>
 #include <optional>
+#include <string>
 
 namespace Json {
 struct JsonMissingKeyError : std::exception

include/xrpl/protocol/jss.h

@@ -268,6 +268,9 @@ JSS(expected_date_UTC);       // out: any (warnings)
 JSS(expected_ledger_size);    // out: TxQ
 JSS(expiration);              // out: AccountOffers, AccountChannels,
                               //      ValidatorList, amm_info
+JSS(extension_compute);       // out: NetworkOps
+JSS(extension_size);          // out: NetworkOps
+JSS(gas_price);               // out: NetworkOps
 JSS(fail_hard);               // in: Sign, Submit
 JSS(failed);                  // out: InboundLedger
 JSS(feature);                 // in: Feature

include/xrpl/resource/Charge.h

@@ -20,6 +20,7 @@
 #ifndef RIPPLE_RESOURCE_CHARGE_H_INCLUDED
 #define RIPPLE_RESOURCE_CHARGE_H_INCLUDED
 
+#include <ios>
 #include <string>
 
 namespace ripple {

include/xrpl/resource/Gossip.h

@@ -22,8 +22,6 @@
 
 #include <xrpl/beast/net/IPEndpoint.h>
 
-#include <vector>
-
 namespace ripple {
 namespace Resource {
 

include/xrpl/server/detail/BaseHTTPPeer.h

@@ -41,6 +41,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <type_traits>
 #include <vector>
 
 namespace ripple {

include/xrpl/server/detail/Door.h

@@ -37,8 +37,10 @@
 #include <boost/container/flat_map.hpp>
 
 #include <chrono>
+#include <condition_variable>
 #include <functional>
 #include <memory>
+#include <mutex>
 
 namespace ripple {
 

include/xrpl/server/detail/io_list.h

@@ -26,6 +26,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <stdexcept>
 #include <type_traits>
 #include <utility>
 

src/libxrpl/basics/FileUtilities.cpp

@@ -28,7 +28,6 @@
 
 #include <cerrno>
 #include <cstddef>
-#include <fstream>
 #include <ios>
 #include <iterator>
 #include <optional>
@@ -56,7 +55,7 @@ getFileContents(
         return {};
     }
 
-    std::ifstream fileStream(fullPath.string(), std::ios::in);
+    ifstream fileStream(fullPath, std::ios::in);
 
     if (!fileStream)
     {
@@ -86,8 +85,7 @@ writeFileContents(
     using namespace boost::filesystem;
     using namespace boost::system::errc;
 
-    std::ofstream fileStream(
-        destPath.string(), std::ios::out | std::ios::trunc);
+    ofstream fileStream(destPath, std::ios::out | std::ios::trunc);
 
     if (!fileStream)
     {

src/libxrpl/protocol/Feature.cpp

@@ -254,7 +254,7 @@ FeatureCollections::registerFeature(
 {
     check(!readOnly, "Attempting to register a feature after startup.");
     check(
-        support == Supported::yes || vote == VoteBehavior::DefaultNo,
+        support == Supported::yes || vote != VoteBehavior::DefaultYes,
         "Invalid feature parameters. Must be supported to be up-voted.");
     Feature const* i = getByName(name);
     if (!i)
@@ -268,7 +268,7 @@ FeatureCollections::registerFeature(
         features.emplace_back(name, f);
 
         auto const getAmendmentSupport = [=]() {
-            if (vote == VoteBehavior::Obsolete)
+            if (vote == VoteBehavior::Obsolete && support == Supported::yes)
                 return AmendmentSupport::Retired;
             return support == Supported::yes ? AmendmentSupport::Supported
                                              : AmendmentSupport::Unsupported;
@@ -398,6 +398,14 @@ retireFeature(std::string const& name)
     return registerFeature(name, Supported::yes, VoteBehavior::Obsolete);
 }
 
+// Abandoned features are not in the ledger and have no code controlled by the
+// feature. They were never supported, and cannot be voted on.
+uint256
+abandonFeature(std::string const& name)
+{
+    return registerFeature(name, Supported::no, VoteBehavior::Obsolete);
+}
+
 /** Tell FeatureCollections when registration is complete. */
 bool
 registrationIsDone()
@@ -432,6 +440,8 @@ featureToName(uint256 const& f)
 #undef XRPL_FIX
 #pragma push_macro("XRPL_RETIRE")
 #undef XRPL_RETIRE
+#pragma push_macro("XRPL_ABANDON")
+#undef XRPL_ABANDON
 
 #define XRPL_FEATURE(name, supported, vote) \
     uint256 const feature##name = registerFeature(#name, supported, vote);
@@ -443,6 +453,11 @@ featureToName(uint256 const& f)
     [[deprecated("The referenced amendment has been retired")]] \
     [[maybe_unused]]                                            \
     uint256 const retired##name = retireFeature(#name);
+
+#define XRPL_ABANDON(name)                                        \
+    [[deprecated("The referenced amendment has been abandoned")]] \
+    [[maybe_unused]]                                              \
+    uint256 const abandoned##name = abandonFeature(#name);
 // clang-format on
 
 #include <xrpl/protocol/detail/features.macro>
@@ -453,6 +468,8 @@ featureToName(uint256 const& f)
 #pragma pop_macro("XRPL_FIX")
 #undef XRPL_FEATURE
 #pragma pop_macro("XRPL_FEATURE")
+#undef XRPL_ABANDON
+#pragma pop_macro("XRPL_ABANDON")
 
 // All of the features should now be registered, since variables in a cpp file
 // are initialized from top to bottom.

src/libxrpl/protocol/PublicKey.cpp

@@ -107,9 +107,8 @@ sliceToHex(Slice const& slice)
     }
     for (int i = 0; i < slice.size(); ++i)
     {
-        constexpr char hex[] = "0123456789ABCDEF";
-        s += hex[((slice[i] & 0xf0) >> 4)];
-        s += hex[((slice[i] & 0x0f) >> 0)];
+        s += "0123456789ABCDEF"[((slice[i] & 0xf0) >> 4)];
+        s += "0123456789ABCDEF"[((slice[i] & 0x0f) >> 0)];
     }
     return s;
 }

src/libxrpl/protocol/STParsedJSON.cpp

@@ -1052,8 +1052,7 @@ parseArray(
             Json::Value const objectFields(json[i][objectName]);
 
             std::stringstream ss;
-            ss << json_name << "."
-               << "[" << i << "]." << objectName;
+            ss << json_name << "." << "[" << i << "]." << objectName;
 
             auto ret = parseObject(
                 ss.str(), objectFields, nameField, depth + 1, error);

src/libxrpl/protocol/STTx.cpp

@@ -671,12 +671,12 @@ isMemoOkay(STObject const& st, std::string& reason)
                     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                     "abcdefghijklmnopqrstuvwxyz");
 
-                for (unsigned char c : symbols)
+                for (char c : symbols)
                     a[c] = 1;
                 return a;
             }();
 
-            for (unsigned char c : *optData)
+            for (auto c : *optData)
             {
                 if (!allowedSymbols[c])
                 {

src/libxrpl/protocol/STValidation.cpp

@@ -78,6 +78,10 @@ STValidation::validationFormat()
         {sfBaseFeeDrops,          soeOPTIONAL},
         {sfReserveBaseDrops,      soeOPTIONAL},
         {sfReserveIncrementDrops, soeOPTIONAL},
+        // featureSmartEscrow
+        {sfExtensionComputeLimit,  soeOPTIONAL},
+        {sfExtensionSizeLimit,     soeOPTIONAL},
+        {sfGasPrice,               soeOPTIONAL},
     };
     // clang-format on