Add shell: bash to each composite action step

.github/actions/extract-version/action.yml

@@ -0,0 +1,21 @@
+name: Extract version
+description: "Extract version from BuildInfo.cpp"
+
+outputs:
+  version:
+    description: "The version extracted from BuildInfo.cpp."
+    value: ${{ steps.version.outputs.version }}
+
+runs:
+  using: composite
+  steps:
+    - name: Extract version
+      id: version
+      shell: bash
+      run: |
+        VERSION="$(cat src/libxrpl/protocol/BuildInfo.cpp | grep "versionString =" | awk -F '"' '{print $2}')"
+        if [[ -z "${VERSION}" ]]; then
+          echo 'Unable to extract version from BuildInfo.cpp.'
+          exit 1
+        fi
+        echo "version=${VERSION}" >> "${GITHUB_OUTPUT}"

.github/actions/upload-recipe/action.yml

@@ -0,0 +1,72 @@
+name: Upload Conan recipe
+description: "Upload recipe to a Conan remote."
+
+inputs:
+  conan_recipe_name:
+    description: "The name of the recipe to use."
+    required: false
+    default: xrpl
+  conan_recipe_version:
+    description: "The version of the recipe to use."
+    required: true
+  conan_recipe_channel:
+    description: "The optional Conan channel to use."
+    required: false
+  conan_recipe_user:
+    description: "The optional Conan user to use."
+    required: false
+  conan_remote_name:
+    description: "The name of the Conan remote to use."
+    required: true
+  conan_remote_url:
+    description: "The URL of the Conan endpoint to use."
+    required: true
+  conan_remote_username:
+    description: "The username for logging into the Conan remote."
+    required: true
+  conan_remote_password:
+    description: "The password for logging into the Conan remote."
+    required: true
+
+outputs:
+  conan_ref: ${{ steps.ref.outputs.ref }}
+
+runs:
+  using: composite
+
+  steps:
+    - name: Calculate Conan reference
+      id: ref
+      shell: bash
+      env:
+        CONAN_RECIPE_NAME: ${{ inputs.conan_recipe_name }}
+        CONAN_RECIPE_VERSION: ${{ inputs.conan_recipe_version }}
+        CONAN_RECIPE_CHANNEL: ${{ inputs.conan_recipe_channel }}
+        CONAN_RECIPE_USER: ${{ inputs.conan_recipe_user }}
+      run: |
+        if [[ -n "${CONAN_RECIPE_USER}" && -n "${CONAN_RECIPE_CHANNEL}" ]]; then
+          echo "ref=${CONAN_RECIPE_NAME}/${CONAN_RECIPE_VERSION}@${CONAN_RECIPE_USER}/${CONAN_RECIPE_CHANNEL}" >> "${GITHUB_OUTPUT}"
+        else
+          echo "ref=${CONAN_RECIPE_NAME}/${CONAN_RECIPE_VERSION}" >> "${GITHUB_OUTPUT}"
+        fi
+    - name: Set up Conan
+      uses: ./.github/actions/setup-conan
+      with:
+        conan_remote_name: ${{ inputs.conan_remote_name }}
+        conan_remote_url: ${{ inputs.conan_remote_url }}
+    - name: Log into Conan remote
+      shell: bash
+      env:
+        CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
+        CONAN_REMOTE_USERNAME: ${{ inputs.conan_remote_username }}
+        CONAN_REMOTE_PASSWORD: ${{ inputs.conan_remote_password }}
+      run: conan remote login "${CONAN_REMOTE_NAME}" "${CONAN_REMOTE_USERNAME}" --password "${CONAN_REMOTE_PASSWORD}"
+    - name: Upload package
+      shell: bash
+      env:
+        CONAN_RECIPE_CHANNEL: ${{ inputs.conan_recipe_channel }}
+        CONAN_RECIPE_USER: ${{ inputs.conan_recipe_user }}
+        CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
+      run: |
+        conan export --channel="${CONAN_RECIPE_CHANNEL}" --user="${CONAN_RECIPE_USER}" .
+        conan upload --confirm --check --remote="${CONAN_REMOTE_NAME}" ${{ steps.ref.outputs.ref }}

.github/workflows/reusable-notify-clio.yml

@@ -44,37 +44,29 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+      - name: Extract version
+        id: version
+        uses: ./.github/actions/extract-version
       - name: Generate outputs
         id: generate
         env:
           PR_NUMBER: ${{ github.event.pull_request.number }}
         run: |
-          echo 'Generating user and channel.'
           echo "user=clio" >> "${GITHUB_OUTPUT}"
           echo "channel=pr_${PR_NUMBER}" >> "${GITHUB_OUTPUT}"
-          echo 'Extracting version.'
-          echo "version=$(cat src/libxrpl/protocol/BuildInfo.cpp | grep "versionString =" | awk -F '"' '{print $2}')" >> "${GITHUB_OUTPUT}"
-      - name: Calculate conan reference
-        id: conan_ref
-        run: |
-          echo "conan_ref=${{ steps.generate.outputs.version }}@${{ steps.generate.outputs.user }}/${{ steps.generate.outputs.channel }}" >> "${GITHUB_OUTPUT}"
-      - name: Set up Conan
-        uses: ./.github/actions/setup-conan
+      - name: Upload recipe
+        uses: ./.github/actions/upload-recipe
+        id: upload
         with:
+          conan_recipe_version: ${{ steps.version.outputs.version }}
+          conan_recipe_channel: ${{ steps.generate.outputs.channel }}
+          conan_recipe_user: ${{ steps.generate.outputs.user }}
           conan_remote_name: ${{ inputs.conan_remote_name }}
           conan_remote_url: ${{ inputs.conan_remote_url }}
-      - name: Log into Conan remote
-        env:
-          CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
-        run: conan remote login "${CONAN_REMOTE_NAME}" "${{ secrets.conan_remote_username }}" --password "${{ secrets.conan_remote_password }}"
-      - name: Upload package
-        env:
-          CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
-        run: |
-          conan export --user=${{ steps.generate.outputs.user }} --channel=${{ steps.generate.outputs.channel }} .
-          conan upload --confirm --check --remote="${CONAN_REMOTE_NAME}" xrpl/${{ steps.conan_ref.outputs.conan_ref }}
+          conan_remote_username: ${{ secrets.conan_remote_username }}
+          conan_remote_password: ${{ secrets.conan_remote_password }}
     outputs:
-      conan_ref: ${{ steps.conan_ref.outputs.conan_ref }}
+      conan_ref: ${{ steps.upload.outputs.conan_ref }}
 
   notify:
     needs: upload

include/xrpl/protocol/detail/features.macro

@@ -16,7 +16,6 @@
 // Add new amendments to the top of this list.
 // Keep it sorted in reverse chronological order.
 
-XRPL_FEATURE(DefragDirectories,          Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (BatchInnerSigs,             Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(LendingProtocol,            Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(PermissionDelegationV1_1,   Supported::no,  VoteBehavior::DefaultNo)

src/libxrpl/ledger/ApplyView.cpp

@@ -10,14 +10,6 @@ namespace xrpl {
 
 namespace directory {
 
-struct Gap
-{
-    uint64_t const page;
-    SLE::pointer node;
-    uint64_t const nextPage;
-    SLE::pointer next;
-};
-
 std::uint64_t
 createRoot(
     ApplyView& view,
@@ -120,9 +112,7 @@ insertPage(
         return std::nullopt;
     if (!view.rules().enabled(fixDirectoryLimit) &&
         page >= dirNodeMaxPages)  // Old pages limit
-    {
         return std::nullopt;
-    }
 
     // We are about to create a new node; we'll link it to
     // the chain first:
@@ -144,8 +134,13 @@ insertPage(
     // it's the default.
     if (page != 1)
         node->setFieldU64(sfIndexPrevious, page - 1);
+    XRPL_ASSERT_PARTS(
+        !nextPage, "xrpl::directory::insertPage", "nextPage has default value");
+    /* Reserved for future use when directory pages may be inserted in
+     * between two other pages instead of only at the end of the chain.
     if (nextPage)
         node->setFieldU64(sfIndexNext, nextPage);
+    */
     describe(node);
     view.insert(node);
 
@@ -161,7 +156,7 @@ ApplyView::dirAdd(
     uint256 const& key,
     std::function<void(std::shared_ptr<SLE> const&)> const& describe)
 {
-    auto const root = peek(directory);
+    auto root = peek(directory);
 
     if (!root)
     {
@@ -172,44 +167,6 @@ ApplyView::dirAdd(
     auto [page, node, indexes] =
         directory::findPreviousPage(*this, directory, root);
 
-    if (rules().enabled(featureDefragDirectories))
-    {
-        // If there are more nodes than just the root, and there's no space in
-        // the last one, walk backwards to find one with space, or to find one
-        // missing.
-        std::optional<directory::Gap> gapPages;
-        while (page && indexes.size() >= dirNodeMaxEntries)
-        {
-            // Find a page with space, or a gap in pages.
-            auto [prevPage, prevNode, prevIndexes] =
-                directory::findPreviousPage(*this, directory, node);
-            if (!gapPages && prevPage != page - 1)
-                gapPages.emplace(prevPage, prevNode, page, node);
-            page = prevPage;
-            node = prevNode;
-            indexes = prevIndexes;
-        }
-        // We looped through all the pages back to the root.
-        if (!page)
-        {
-            // If we found a gap, use it.
-            if (gapPages)
-            {
-                return directory::insertPage(
-                    *this,
-                    gapPages->page,
-                    gapPages->node,
-                    gapPages->nextPage,
-                    gapPages->next,
-                    key,
-                    directory,
-                    describe);
-            }
-            std::tie(page, node, indexes) =
-                directory::findPreviousPage(*this, directory, root);
-        }
-    }
-
     // If there's space, we use it:
     if (indexes.size() < dirNodeMaxEntries)
     {