fix clang-tidy findings in the new SLEBase throw-coverage test

const-correctness on env, and an explicit <stdexcept> include for
std::logic_error.

.github/actions/cargo-cache/action.yml

@@ -20,9 +20,10 @@ inputs:
     required: false
     default: ""
   save-if:
-    description: "Condition for saving the cache after the job."
+    description: >
+      Condition for saving the cache after the job. Defaults to save only from develop branch
     required: false
-    default: "true"
+    default: ${{ github.ref == 'refs/heads/develop' }}
 
 runs:
   using: composite

.github/workflows/reusable-build-test-config.yml

@@ -167,7 +167,6 @@ jobs:
         with:
           cache-directories: ${{ env.BUILD_DIR }}/corrosion
           key: ${{ inputs.config_name }}
-          save-if: ${{ github.ref == 'refs/heads/develop' || startsWith(github.ref, 'refs/heads/release') }}
           # two workspaces here because build artifacts are located in 2 places:
           # - crates/target when cargo is called directly
           # - build/cargo when cargo is called by cmake

.github/workflows/reusable-clang-tidy.yml

@@ -63,7 +63,6 @@ jobs:
         uses: ./.github/actions/cargo-cache
         with:
           cache-directories: ${{ env.BUILD_DIR }}/corrosion
-          save-if: ${{ github.ref == 'refs/heads/develop' || startsWith(github.ref, 'refs/heads/release') }}
           workspaces: crates -> ../${{ env.BUILD_DIR }}/cargo
 
       - name: Setup Conan

API-CHANGELOG.md

@@ -54,6 +54,9 @@ This section contains changes targeting a future version.
 - `submit`: The `fail_hard` field now returns an error if the value is not a boolean. [#6529](https://github.com/XRPLF/rippled/pull/6529)
 - `subscribe`: The `taker` field in the `books` array now returns `actMalformed` instead of `badIssuer` if the value is not a valid account. [#6529](https://github.com/XRPLF/rippled/pull/6529)
 - Fixed a bug in `Forwarded` HTTP header parsing where the extracted IP address could be incorrect when no comma or semicolon delimiter follows the address. This could cause the server to misidentify a client's IP address when operating behind a reverse proxy. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `vault_info`: Errors now identify what the request got wrong instead of reporting every failure as the unregistered token `malformedRequest`, and the `error`, `error_code` and `error_message` fields now agree with each other. An invalid `vault_id` or `seq` returns `invalidParams`, an invalid `owner` returns `actMalformed`, and a request that mixes `vault_id` with `owner`/`seq` or supplies neither returns `invalidParams` with a message naming the accepted combinations. [#8015](https://github.com/XRPLF/rippled/pull/8015)
+- `vault_info`: A well-formed all-zero `vault_id` now returns `entryNotFound` instead of being rejected as malformed, and `entryNotFound` responses now include `error_code` and `error_message`. Clients that request `ripplerpc` 3.0 or above therefore receive HTTP 400 with that error rather than HTTP 200. [#8015](https://github.com/XRPLF/rippled/pull/8015)
+- `vault_info`: `vault_id` and `owner` must now be strings, matching how `ledger_entry` reads the same fields. An object or an array in either field previously produced an internal error, and a number was silently converted to its decimal text; `vault_id` now returns `invalidParams` and `owner` returns `actMalformed`. [#8015](https://github.com/XRPLF/rippled/pull/8015)
 - `gateway_balances`: The `account` and `ident` fields now return an `invalidParams` error if the value is not a string, instead of an `internal` error. [#7655](https://github.com/XRPLF/rippled/pull/7655)
 - `account_lines`: The `peer` field now returns an error if the value is not a string. [#7728](https://github.com/XRPLF/rippled/pull/7728)
 

cmake/scripts/codegen/generate_tx_classes.py

@@ -8,6 +8,7 @@ Uses pcpp to preprocess the macro file and pyparsing to parse the DSL.
 
 import io
 import argparse
+import re
 from pathlib import Path
 import pyparsing as pp
 
@@ -53,28 +54,89 @@ def create_transaction_parser():
     return macro_parser
 
 
+# Defaults for xrpl::TxSettings members, mirroring
+# include/xrpl/protocol/TxSettings.h. A transaction's settings blob only names
+# the members that differ from these.
+SETTING_DEFAULTS = {
+    "delegable": "Delegation::NotDelegable",
+    "amendment": "uint256{}",
+    "privileges": "Privilege::NoPriv",
+}
+
+
+def parse_settings(settings_str):
+    """Parse a TxSettings blob into a dict, filling in defaults.
+
+    Args:
+        settings_str: A string like '({.delegable = Delegation::NotDelegable,
+                      .privileges = Privilege::CreateAcct})', or '({})'.
+
+    Returns:
+        A dict with a value for every key in SETTING_DEFAULTS.
+    """
+    body = settings_str.strip()
+    if not (body.startswith("(") and body.endswith(")")):
+        raise ValueError(
+            f"Malformed settings blob, expected '({{...}})': {settings_str!r}"
+        )
+    body = body[1:-1].strip()
+    if not (body.startswith("{") and body.endswith("}")):
+        raise ValueError(
+            f"Malformed settings blob, expected '({{...}})': {settings_str!r}"
+        )
+    body = body[1:-1]
+
+    # Strip comments, which may be interleaved with the designated initializers.
+    body = re.sub(r"//[^\n]*", "", body)
+
+    settings = dict(SETTING_DEFAULTS)
+    seen = set()
+    # Each entry runs from '.key =' up to the next '.key =' or the end.
+    for key, value in re.findall(
+        r"\.(\w+)\s*=\s*(.*?)(?=,\s*\.\w+\s*=|,?\s*$)", body, re.S
+    ):
+        if key not in SETTING_DEFAULTS:
+            raise ValueError(f"Unknown TxSettings member '.{key}' in {settings_str!r}")
+        settings[key] = " ".join(value.split()).rstrip(",")
+        seen.add(key)
+
+    # Catch a typo'd or unparsed initializer rather than silently defaulting it.
+    # Every '.member' in the blob must have been consumed above.
+    if len(re.findall(r"\.\w+", body)) != len(seen):
+        raise ValueError(f"Could not parse every setting in {settings_str!r}")
+
+    # A blob with content but no designated initializer is positional, which
+    # would otherwise be read as "all defaults" and silently generate the
+    # wrong output.
+    if body.strip() and not seen:
+        raise ValueError(
+            "TxSettings requires designated initializers (.member = value), "
+            f"got {settings_str!r}"
+        )
+
+    return settings
+
+
 def parse_transaction_args(args_list):
     """Parse the arguments of a TRANSACTION macro call.
 
     Args:
         args_list: A list of parsed arguments from pyparsing, e.g.,
-                   ['ttPAYMENT', '0', 'Payment', 'Delegation::delegable',
-                    'uint256{}', 'createAcct', '({...})']
+                   ['ttPAYMENT', '0', 'Payment',
+                    '({.privileges = Privilege::CreateAcct})', '({...})']
 
     Returns:
         A dict with parsed transaction information.
     """
-    if len(args_list) < 7:
+    if len(args_list) < 5:
         raise ValueError(
-            f"Expected at least 7 parts in TRANSACTION, got {len(args_list)}: {args_list}"
+            f"Expected at least 5 parts in TRANSACTION, got {len(args_list)}: {args_list}"
         )
 
     tag = args_list[0]
     value = args_list[1]
     name = args_list[2]
-    delegable = args_list[3]
-    amendments = args_list[4]
-    privileges = args_list[5]
+    settings = parse_settings(args_list[3])
     fields_str = args_list[-1]
 
     # Parse fields: ({field1, field2, ...})
@@ -84,9 +146,9 @@ def parse_transaction_args(args_list):
         "tag": tag,
         "value": value,
         "name": name,
-        "delegable": delegable,
-        "amendments": amendments,
-        "privileges": privileges,
+        "delegable": settings["delegable"],
+        "amendments": settings["amendment"],
+        "privileges": settings["privileges"],
         "fields": fields,
     }
 

docs/install.md

@@ -92,11 +92,11 @@ wherever it appears in the repository configuration.
 2.  Add the repository, using the channel you picked in [Release channels](#release-channels):
 
     ```bash
-    cat << REPOFILE | sudo tee /etc/yum.repos.d/xrplf.repo
+    cat << 'REPOFILE' | sudo tee /etc/yum.repos.d/xrplf.repo
     [xrplf-stable]
     name=XRP Ledger Packages
     enabled=1
-    baseurl=https://packages.xrplf.org/repository/rpm-stable/
+    baseurl=https://packages.xrplf.org/repository/rpm-stable/$basearch/
     gpgcheck=1
     repo_gpgcheck=1
     gpgkey=https://packages.xrplf.org/xrplf.asc

include/xrpl/ledger/View.h

@@ -24,6 +24,7 @@
 #include <optional>
 #include <set>
 #include <utility>
+#include <vector>
 
 namespace xrpl {
 
@@ -198,7 +199,10 @@ dirLink(
  *      if withdrawing to self.
  *    - If withdrawing to self, succeed.
  *    - If not, checks if the receiver requires deposit authorization, and if
- *      the sender has it.
+ *      the sender has it (account-based or credential-based).
+ *    - Expects any credentials passed in to already exist in the ledger, and
+ *      returns an internal error otherwise. Validate them beforehand with
+ *      credentials::valid().
  *    - Checks that the receiver will not exceed the limit (IOU trustline limit
  *      or MPT MaximumAmount).
  */
@@ -209,7 +213,8 @@ canWithdraw(
     AccountID const& to,
     SLE::const_ref toSle,
     STAmount const& amount,
-    bool hasDestinationTag);
+    bool hasDestinationTag,
+    std::optional<std::vector<uint256>> const& credentialIDs = std::nullopt);
 
 /**
  * Checks that can withdraw funds from an object to itself or a destination.
@@ -222,7 +227,10 @@ canWithdraw(
  *      if withdrawing to self.
  *    - If withdrawing to self, succeed.
  *    - If not, checks if the receiver requires deposit authorization, and if
- *      the sender has it.
+ *      the sender has it (account-based or credential-based).
+ *    - Expects any credentials passed in to already exist in the ledger, and
+ *      returns an internal error otherwise. Validate them beforehand with
+ *      credentials::valid().
  *    - Checks that the receiver will not exceed the limit (IOU trustline limit
  *      or MPT MaximumAmount).
  */
@@ -232,20 +240,25 @@ canWithdraw(
     AccountID const& from,
     AccountID const& to,
     STAmount const& amount,
-    bool hasDestinationTag);
+    bool hasDestinationTag,
+    std::optional<std::vector<uint256>> const& credentialIDs = std::nullopt);
 
 /**
  * Checks that can withdraw funds from an object to itself or a destination.
  *
  * The receiver may be either the submitting account (sfAccount) or a different
- * destination account (sfDestination).
+ * destination account (sfDestination). Credentials, if any, are taken from the
+ * transaction's sfCredentialIDs field.
  *
  *    - Checks that the receiver account exists.
  *    - If the receiver requires a destination tag, check that one exists, even
  *      if withdrawing to self.
  *    - If withdrawing to self, succeed.
  *    - If not, checks if the receiver requires deposit authorization, and if
- *      the sender has it.
+ *      the sender has it (account-based or credential-based).
+ *    - Expects any credentials in sfCredentialIDs to already exist in the
+ *      ledger, and returns an internal error otherwise. Validate them
+ *      beforehand with credentials::valid().
  *    - Checks that the receiver will not exceed the limit (IOU trustline limit
  *      or MPT MaximumAmount).
  */

include/xrpl/ledger/helpers/AMMEntry.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class AMMEntry : public SLEBase<ViewT, ltAMM>
+{
+public:
+    using Base = SLEBase<ViewT, ltAMM>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit AMMEntry(
+        Asset const& issue1,
+        Asset const& issue2,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::amm(issue1, issue2), view, j)
+    {
+    }
+
+    explicit AMMEntry(
+        uint256 const& ammID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::amm(ammID), view, j)
+    {
+    }
+};
+
+using RAMMEntry = AMMEntry<ReadView>;
+using WAMMEntry = AMMEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/AccountRootEntry.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class AccountRootEntry : public SLEBase<ViewT, ltACCOUNT_ROOT>
+{
+public:
+    using Base = SLEBase<ViewT, ltACCOUNT_ROOT>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit AccountRootEntry(
+        AccountID const& id,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::account(id), view, j)
+    {
+    }
+};
+
+using RAccountRootEntry = AccountRootEntry<ReadView>;
+using WAccountRootEntry = AccountRootEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/AmendmentsEntry.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class AmendmentsEntry : public SLEBase<ViewT, ltAMENDMENTS>
+{
+public:
+    using Base = SLEBase<ViewT, ltAMENDMENTS>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit AmendmentsEntry(
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::amendments(), view, j)
+    {
+    }
+};
+
+using RAmendmentsEntry = AmendmentsEntry<ReadView>;
+using WAmendmentsEntry = AmendmentsEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/BridgeEntry.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STXChainBridge.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class BridgeEntry : public SLEBase<ViewT, ltBRIDGE>
+{
+public:
+    using Base = SLEBase<ViewT, ltBRIDGE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit BridgeEntry(
+        STXChainBridge const& bridge,
+        STXChainBridge::ChainType chainType,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::bridge(bridge, chainType), view, j)
+    {
+    }
+};
+
+using RBridgeEntry = BridgeEntry<ReadView>;
+using WBridgeEntry = BridgeEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/CheckEntry.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class CheckEntry : public SLEBase<ViewT, ltCHECK>
+{
+public:
+    using Base = SLEBase<ViewT, ltCHECK>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit CheckEntry(
+        AccountID const& id,
+        SeqProxy const& seq,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::check(id, seq), view, j)
+    {
+    }
+
+    explicit CheckEntry(
+        uint256 const& checkID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::check(checkID), view, j)
+    {
+    }
+};
+
+using RCheckEntry = CheckEntry<ReadView>;
+using WCheckEntry = CheckEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/CredentialEntry.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class CredentialEntry : public SLEBase<ViewT, ltCREDENTIAL>
+{
+public:
+    using Base = SLEBase<ViewT, ltCREDENTIAL>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit CredentialEntry(
+        AccountID const& subject,
+        AccountID const& issuer,
+        Slice const& credType,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::credential(subject, issuer, credType), view, j)
+    {
+    }
+
+    explicit CredentialEntry(
+        uint256 const& credentialID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::credential(credentialID), view, j)
+    {
+    }
+};
+
+using RCredentialEntry = CredentialEntry<ReadView>;
+using WCredentialEntry = CredentialEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/DIDEntry.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class DIDEntry : public SLEBase<ViewT, ltDID>
+{
+public:
+    using Base = SLEBase<ViewT, ltDID>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit DIDEntry(
+        AccountID const& account,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::did(account), view, j)
+    {
+    }
+};
+
+using RDIDEntry = DIDEntry<ReadView>;
+using WDIDEntry = DIDEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/DelegateEntry.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class DelegateEntry : public SLEBase<ViewT, ltDELEGATE>
+{
+public:
+    using Base = SLEBase<ViewT, ltDELEGATE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit DelegateEntry(
+        AccountID const& account,
+        AccountID const& authorizedAccount,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::delegate(account, authorizedAccount), view, j)
+    {
+    }
+};
+
+using RDelegateEntry = DelegateEntry<ReadView>;
+using WDelegateEntry = DelegateEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/DepositPreauthEntry.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+#include <set>
+#include <utility>
+
+namespace xrpl {
+
+template <typename ViewT>
+class DepositPreauthEntry : public SLEBase<ViewT, ltDEPOSIT_PREAUTH>
+{
+public:
+    using Base = SLEBase<ViewT, ltDEPOSIT_PREAUTH>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit DepositPreauthEntry(
+        AccountID const& owner,
+        AccountID const& preauthorized,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::depositPreauth(owner, preauthorized), view, j)
+    {
+    }
+
+    explicit DepositPreauthEntry(
+        AccountID const& owner,
+        std::set<std::pair<AccountID, Slice>> const& authCreds,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::depositPreauth(owner, authCreds), view, j)
+    {
+    }
+
+    explicit DepositPreauthEntry(
+        uint256 const& preauthID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::depositPreauth(preauthID), view, j)
+    {
+    }
+};
+
+using RDepositPreauthEntry = DepositPreauthEntry<ReadView>;
+using WDepositPreauthEntry = DepositPreauthEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/DirectoryNodeEntry.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+template <typename ViewT>
+class DirectoryNodeEntry : public SLEBase<ViewT, ltDIR_NODE>
+{
+public:
+    using Base = SLEBase<ViewT, ltDIR_NODE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit DirectoryNodeEntry(
+        AccountID const& id,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::ownerDir(id), view, j)
+    {
+    }
+
+    /**
+     * Resolve a specific page of the directory rooted at @p root.
+     */
+    explicit DirectoryNodeEntry(
+        uint256 const& root,
+        std::uint64_t index,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::page(root, index), view, j)
+    {
+    }
+};
+
+using RDirectoryNodeEntry = DirectoryNodeEntry<ReadView>;
+using WDirectoryNodeEntry = DirectoryNodeEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/EscrowEntry.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class EscrowEntry : public SLEBase<ViewT, ltESCROW>
+{
+public:
+    using Base = SLEBase<ViewT, ltESCROW>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit EscrowEntry(
+        AccountID const& src,
+        SeqProxy const& seq,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::escrow(src, seq), view, j)
+    {
+    }
+};
+
+using REscrowEntry = EscrowEntry<ReadView>;
+using WEscrowEntry = EscrowEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/FeeSettingsEntry.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class FeeSettingsEntry : public SLEBase<ViewT, ltFEE_SETTINGS>
+{
+public:
+    using Base = SLEBase<ViewT, ltFEE_SETTINGS>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit FeeSettingsEntry(
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::feeSettings(), view, j)
+    {
+    }
+};
+
+using RFeeSettingsEntry = FeeSettingsEntry<ReadView>;
+using WFeeSettingsEntry = FeeSettingsEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/LedgerHashesEntry.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class LedgerHashesEntry : public SLEBase<ViewT, ltLEDGER_HASHES>
+{
+public:
+    using Base = SLEBase<ViewT, ltLEDGER_HASHES>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit LedgerHashesEntry(
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::skip(), view, j)
+    {
+    }
+};
+
+using RLedgerHashesEntry = LedgerHashesEntry<ReadView>;
+using WLedgerHashesEntry = LedgerHashesEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/LoanBrokerEntry.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class LoanBrokerEntry : public SLEBase<ViewT, ltLOAN_BROKER>
+{
+public:
+    using Base = SLEBase<ViewT, ltLOAN_BROKER>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit LoanBrokerEntry(
+        AccountID const& owner,
+        SeqProxy const& seq,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::loanBroker(owner, seq), view, j)
+    {
+    }
+
+    explicit LoanBrokerEntry(
+        uint256 const& loanBrokerID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::loanBroker(loanBrokerID), view, j)
+    {
+    }
+};
+
+using RLoanBrokerEntry = LoanBrokerEntry<ReadView>;
+using WLoanBrokerEntry = LoanBrokerEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/LoanEntry.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class LoanEntry : public SLEBase<ViewT, ltLOAN>
+{
+public:
+    using Base = SLEBase<ViewT, ltLOAN>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit LoanEntry(
+        uint256 const& loanBrokerID,
+        SeqProxy const& loanSeq,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::loan(loanBrokerID, loanSeq), view, j)
+    {
+    }
+
+    explicit LoanEntry(
+        uint256 const& loanID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::loan(loanID), view, j)
+    {
+    }
+};
+
+using RLoanEntry = LoanEntry<ReadView>;
+using WLoanEntry = LoanEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/MPTokenEntry.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/UintTypes.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class MPTokenEntry : public SLEBase<ViewT, ltMPTOKEN>
+{
+public:
+    using Base = SLEBase<ViewT, ltMPTOKEN>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit MPTokenEntry(
+        MPTID const& issuanceID,
+        AccountID const& holder,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::mptoken(issuanceID, holder), view, j)
+    {
+    }
+
+    explicit MPTokenEntry(
+        uint256 const& issuanceKey,
+        AccountID const& holder,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::mptoken(issuanceKey, holder), view, j)
+    {
+    }
+
+    explicit MPTokenEntry(
+        uint256 const& mptokenKey,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::mptoken(mptokenKey), view, j)
+    {
+    }
+};
+
+using RMPTokenEntry = MPTokenEntry<ReadView>;
+using WMPTokenEntry = MPTokenEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/MPTokenIssuanceEntry.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/UintTypes.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+template <typename ViewT>
+class MPTokenIssuanceEntry : public SLEBase<ViewT, ltMPTOKEN_ISSUANCE>
+{
+public:
+    using Base = SLEBase<ViewT, ltMPTOKEN_ISSUANCE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit MPTokenIssuanceEntry(
+        std::uint32_t seq,
+        AccountID const& issuer,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::mptokenIssuance(makeMptID(seq, issuer)), view, j)
+    {
+    }
+
+    explicit MPTokenIssuanceEntry(
+        MPTID const& issuanceID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::mptokenIssuance(issuanceID), view, j)
+    {
+    }
+
+    explicit MPTokenIssuanceEntry(
+        uint256 const& issuanceKey,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::mptokenIssuance(issuanceKey), view, j)
+    {
+    }
+};
+
+using RMPTokenIssuanceEntry = MPTokenIssuanceEntry<ReadView>;
+using WMPTokenIssuanceEntry = MPTokenIssuanceEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/NFTokenOfferEntry.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class NFTokenOfferEntry : public SLEBase<ViewT, ltNFTOKEN_OFFER>
+{
+public:
+    using Base = SLEBase<ViewT, ltNFTOKEN_OFFER>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit NFTokenOfferEntry(
+        AccountID const& owner,
+        SeqProxy const& seq,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::nftokenOffer(owner, seq), view, j)
+    {
+    }
+
+    explicit NFTokenOfferEntry(
+        uint256 const& offerID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::nftokenOffer(offerID), view, j)
+    {
+    }
+};
+
+using RNFTokenOfferEntry = NFTokenOfferEntry<ReadView>;
+using WNFTokenOfferEntry = NFTokenOfferEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/NFTokenPageEntry.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class NFTokenPageEntry : public SLEBase<ViewT, ltNFTOKEN_PAGE>
+{
+public:
+    using Base = SLEBase<ViewT, ltNFTOKEN_PAGE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit NFTokenPageEntry(
+        Keylet const& page,
+        uint256 const& token,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::nftokenPage(page, token), view, j)
+    {
+    }
+};
+
+using RNFTokenPageEntry = NFTokenPageEntry<ReadView>;
+using WNFTokenPageEntry = NFTokenPageEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/NegativeUNLEntry.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class NegativeUNLEntry : public SLEBase<ViewT, ltNEGATIVE_UNL>
+{
+public:
+    using Base = SLEBase<ViewT, ltNEGATIVE_UNL>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit NegativeUNLEntry(
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::negativeUNL(), view, j)
+    {
+    }
+};
+
+using RNegativeUNLEntry = NegativeUNLEntry<ReadView>;
+using WNegativeUNLEntry = NegativeUNLEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/OfferEntry.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class OfferEntry : public SLEBase<ViewT, ltOFFER>
+{
+public:
+    using Base = SLEBase<ViewT, ltOFFER>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit OfferEntry(
+        AccountID const& id,
+        SeqProxy const& seq,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::offer(id, seq), view, j)
+    {
+    }
+
+    explicit OfferEntry(
+        uint256 const& offerID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::offer(offerID), view, j)
+    {
+    }
+};
+
+using ROfferEntry = OfferEntry<ReadView>;
+using WOfferEntry = OfferEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/OracleEntry.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+template <typename ViewT>
+class OracleEntry : public SLEBase<ViewT, ltORACLE>
+{
+public:
+    using Base = SLEBase<ViewT, ltORACLE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit OracleEntry(
+        AccountID const& account,
+        std::uint32_t documentID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::oracle(account, documentID), view, j)
+    {
+    }
+};
+
+using ROracleEntry = OracleEntry<ReadView>;
+using WOracleEntry = OracleEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/PayChannelEntry.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class PayChannelEntry : public SLEBase<ViewT, ltPAYCHAN>
+{
+public:
+    using Base = SLEBase<ViewT, ltPAYCHAN>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit PayChannelEntry(
+        AccountID const& src,
+        AccountID const& dst,
+        SeqProxy const& seq,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::payChannel(src, dst, seq), view, j)
+    {
+    }
+};
+
+using RPayChannelEntry = PayChannelEntry<ReadView>;
+using WPayChannelEntry = PayChannelEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/PermissionedDomainEntry.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class PermissionedDomainEntry : public SLEBase<ViewT, ltPERMISSIONED_DOMAIN>
+{
+public:
+    using Base = SLEBase<ViewT, ltPERMISSIONED_DOMAIN>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit PermissionedDomainEntry(
+        AccountID const& account,
+        SeqProxy const& seq,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::permissionedDomain(account, seq), view, j)
+    {
+    }
+
+    explicit PermissionedDomainEntry(
+        uint256 const& domainID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::permissionedDomain(domainID), view, j)
+    {
+    }
+};
+
+using RPermissionedDomainEntry = PermissionedDomainEntry<ReadView>;
+using WPermissionedDomainEntry = PermissionedDomainEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/RippleStateEntry.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Issue.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/UintTypes.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class RippleStateEntry : public SLEBase<ViewT, ltRIPPLE_STATE>
+{
+public:
+    using Base = SLEBase<ViewT, ltRIPPLE_STATE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit RippleStateEntry(
+        AccountID const& id0,
+        AccountID const& id1,
+        Currency const& currency,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::trustLine(id0, id1, currency), view, j)
+    {
+    }
+
+    explicit RippleStateEntry(
+        AccountID const& id,
+        Issue const& issue,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::trustLine(id, issue), view, j)
+    {
+    }
+};
+
+using RRippleStateEntry = RippleStateEntry<ReadView>;
+using WRippleStateEntry = RippleStateEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/SLEBase.h

@@ -0,0 +1,493 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/contract.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+
+#include <concepts>
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+namespace xrpl {
+
+// Concept to distinguish read-only vs writable view types
+template <typename V>
+concept WritableView = std::derived_from<V, ApplyView>;
+
+namespace detail {
+
+/**
+ * Resolves a keylet for a read-only entry.
+ *
+ * ReadView::read() on an ApplyView returns the underlying ledger's entry
+ * whenever the view is not already tracking one, while peek() installs the
+ * view's own copy and returns that. A read-only entry built with read()
+ * would therefore hold an SLE that goes stale the moment anything peeks the
+ * same key and modifies it. Resolve through peek() whenever the view really is
+ * an ApplyView, so every entry over that view shares one SLE.
+ *
+ * @note The const_cast is what makes reaching ApplyView::peek() possible, and
+ *       it is safe only because xrpld never instantiates a ReadView as a
+ *       genuinely const object -- every view is a non-const object that some
+ *       call sites merely observe through a const reference. If an actually
+ *       const-qualified view type is ever introduced (an immutable snapshot,
+ *       say), this becomes undefined behavior and must be revisited.
+ *
+ * @note Consequently a "read-only" entry over an ApplyView is not free of
+ *       side effects: peek() installs an Action::Cache entry in the apply
+ *       state table. That is benign for transaction metadata -- Cache entries
+ *       are skipped in ApplyStateTable::apply(), ::visit() and in metadata
+ *       generation -- but it does cost one deep SLE copy on first touch.
+ */
+inline SLE::const_pointer
+resolveEntry(ReadView const& view, Keylet const& key)
+{
+    // Views are never const objects; the read-only entry only holds a const
+    // reference because it does not itself modify the view.
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
+    if (auto const applyView = dynamic_cast<ApplyView*>(const_cast<ReadView*>(&view)))
+        return applyView->peek(key);
+    return view.read(key);
+}
+
+}  // namespace detail
+
+/**
+ * View-parameterized base class for all ledger entries.
+ *
+ * SLEBase<ReadView>  — read-only:  holds shared_ptr<SLE const> + ReadView const&
+ * SLEBase<ApplyView> — writable:   holds shared_ptr<SLE> + ApplyView& + Keylet,
+ *                                   plus insert/update/erase operations
+ *
+ * Write-only members are gated by `requires` clauses, providing compile-time
+ * guarantees that read-only entries cannot mutate state.
+ *
+ * @tparam EntryType the ledger entry type this entry is statically bound to.
+ * Derived per-type entries pass their own type (e.g. ltACCOUNT_ROOT); the
+ * generic ReadOnlySLE / WritableSLE aliases leave it at ltANY, which opts out
+ * of the static type check. Binding the type here is what keeps an entry for
+ * one entry type from being constructed or converted from another -- see the
+ * converting constructor below.
+ *
+ * Derived classes should provide domain-specific accessors that hide
+ * implementation details of the underlying ledger entry format.
+ */
+template <typename ViewT, LedgerEntryType EntryType = ltANY>
+class SLEBase
+{
+public:
+    static constexpr bool kIsWritable = WritableView<ViewT>;
+
+    // The ledger entry type this entry is bound to, and whether that binding
+    // is meaningful (ltANY means "any type", i.e. no static check).
+    static constexpr LedgerEntryType kEntryType = EntryType;
+    static constexpr bool kIsTyped = (EntryType != ltANY);
+
+    // SLE pointer type: mutable for writable views, const for read-only
+    using sle_ptr_type = std::conditional_t<kIsWritable, SLE::pointer, SLE::const_pointer>;
+
+    // View reference type: ApplyView& for writable, ReadView const& for
+    // read-only
+    using view_ref_type = std::conditional_t<kIsWritable, ApplyView&, ReadView const&>;
+
+    // Non-virtual by design: these entries are parameterized on the view and
+    // entry type, never used polymorphically through a base pointer. A vptr
+    // would be 8 bytes of pure overhead on a type meant to be as cheap as the
+    // shared_ptr it wraps. See the static_assert below the class.
+    //
+    // The destructor is public because the ReadOnlySLE / WritableSLE aliases
+    // name this class directly and are used as value types. Since it is not
+    // virtual, never delete a derived entry through an SLEBase*.
+    ~SLEBase() = default;
+
+    SLEBase(SLEBase const&) = default;
+    SLEBase(SLEBase&&) = default;
+    SLEBase&
+    operator=(SLEBase const&) = delete;
+    SLEBase&
+    operator=(SLEBase&&) = delete;
+    SLEBase() = delete;
+
+    // --- Constructors that adopt/resolve an SLE (public so the ReadOnlySLE /
+    //     WritableSLE aliases and the per-type entries can be built directly
+    //     from a keylet, or -- read-only only -- from an already-fetched
+    //     SLE). ---
+
+    /**
+     * Constructor for read-only context (adopt an already-fetched SLE).
+     *
+     * There is deliberately no writable equivalent: a writable entry needs
+     * a Keylet so that newSLE() can still build an entry when none exists,
+     * and that cannot be recovered from a null SLE.
+     */
+    explicit SLEBase(
+        SLE::const_pointer sle,
+        view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        requires(!kIsWritable)
+        : view_(view), sle_(std::move(sle)), j_(j)
+    {
+        XRPL_ASSERT(
+            !kIsTyped || !sle_ || sle_->getType() == kEntryType,
+            "xrpl::SLEBase::SLEBase : adopted SLE matches bound entry type");
+    }
+
+    /**
+     * Constructor for read-only context (read from view by keylet)
+     */
+    explicit SLEBase(
+        Keylet const& key,
+        view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        requires(!kIsWritable)
+        : view_(view), sle_(detail::resolveEntry(view, key)), j_(j)
+    {
+        XRPL_ASSERT(
+            !kIsTyped || key.type == kEntryType,
+            "xrpl::SLEBase::SLEBase : keylet matches bound entry type");
+    }
+
+    /**
+     * Converting constructor: writable → read-only.
+     *
+     * Enables implicit conversion from SLEBase<ApplyView> to
+     * SLEBase<ReadView>, so functions taking ReadOnlySLE const& can accept
+     * WritableSLE.
+     *
+     * Constrained to the same entry type (or to a ltANY target, i.e. widening
+     * a typed entry to a generic ReadOnlySLE). The constraint is load-bearing:
+     * this constructor is inherited into every per-type entry, and unconstrained
+     * it would bind any writable entry that slices to SLEBase, so a WOfferEntry
+     * would convert to an RAccountRootEntry with no cast at the call site.
+     */
+    template <typename OtherViewT, LedgerEntryType OtherType>
+    SLEBase(SLEBase<OtherViewT, OtherType> const& other)
+        requires(!kIsWritable && WritableView<OtherViewT> &&
+                 (OtherType == EntryType || EntryType == ltANY))
+        : view_(other.readView()), sle_(other.rawSle()), j_(other.journal())
+    {
+    }
+
+    /**
+     * Constructor for writable context (peek from view by keylet)
+     */
+    explicit SLEBase(
+        Keylet const& key,
+        ApplyView& view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        requires kIsWritable
+        : view_(view), key_(key), sle_(view_.peek(key)), j_(j)
+    {
+        XRPL_ASSERT(
+            !kIsTyped || key.type == kEntryType,
+            "xrpl::SLEBase::SLEBase : keylet matches bound entry type");
+    }
+
+    /**
+     * Constructor for writable context, for call sites that hold an
+     * ApplyViewContext (peek from ctx.view by keylet).
+     *
+     * ctx.tx is not retained: this exists purely so transactors can pass the
+     * context they already have instead of spelling out ctx.view. If an entry
+     * ever needs the applying transaction, store it here rather than adding
+     * another overload.
+     */
+    explicit SLEBase(
+        Keylet const& key,
+        ApplyViewContext const& ctx,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        requires kIsWritable
+        : SLEBase(key, ctx.view, j)
+    {
+    }
+
+    // --- Common interface (always available) ---
+
+    /**
+     * Returns true if the ledger entry exists
+     */
+    [[nodiscard]] bool
+    exists() const
+    {
+        return sle_ != nullptr;
+    }
+
+    /**
+     * Explicit conversion to bool for convenient existence checking
+     */
+    explicit
+    operator bool() const
+    {
+        return exists();
+    }
+
+    /**
+     * Returns the underlying SLE for read access.
+     *
+     * Prefer operator-> / operator* for field access; this is for the call
+     * sites that need the shared_ptr itself.
+     */
+    [[nodiscard]] SLE::const_pointer
+    rawSle() const
+    {
+        return sle_;
+    }
+
+    /**
+     * Returns the ledger entry type of this entry.
+     *
+     * For a per-type entry this is kEntryType, known at compile time and
+     * valid whether or not the entry exists. Only the generic ReadOnlySLE /
+     * WritableSLE aliases have to read it back out of the SLE.
+     *
+     * @throws std::logic_error for a generic (ltANY) entry if exists() is
+     *         false.
+     */
+    [[nodiscard]] LedgerEntryType
+    type() const
+    {
+        if constexpr (kIsTyped)
+        {
+            return kEntryType;
+        }
+        else
+        {
+            if (!exists())
+                Throw<std::logic_error>("xrpl::SLEBase::type : entry does not exist");
+            return sle_->getType();
+        }
+    }
+
+    /**
+     * Returns the keylet identifying this entry.
+     *
+     * Writable entries keep the keylet they were built from, so it is valid
+     * even before newSLE(). Read-only entries derive it from the SLE, which
+     * must therefore exist.
+     *
+     * @throws std::logic_error for a read-only entry if exists() is false.
+     */
+    [[nodiscard]] Keylet
+    keylet() const
+    {
+        if constexpr (kIsWritable)
+        {
+            return key_;
+        }
+        else
+        {
+            if (!exists())
+                Throw<std::logic_error>("xrpl::SLEBase::keylet : entry does not exist");
+            // Take the type from the SLE, not from kEntryType: the adopt-SLE
+            // constructor's type check is assert-only, so a Release build can
+            // be holding an SLE whose type disagrees with the binding, and the
+            // SLE is the one telling the truth.
+            return Keylet(sle_->getType(), sle_->key());
+        }
+    }
+
+    /**
+     * Returns the ledger key of this entry.
+     *
+     * @throws std::logic_error same as keylet(): for read-only entries,
+     *         if exists() is false.
+     */
+    [[nodiscard]] uint256
+    key() const
+    {
+        return keylet().key;
+    }
+
+    /**
+     * Returns the read view (always available; ApplyView inherits ReadView)
+     */
+    [[nodiscard]] ReadView const&
+    readView() const
+    {
+        return view_;
+    }
+
+    /**
+     * Const dereference operators (always available)
+     *
+     * @throws std::logic_error if exists() is false.
+     */
+    STLedgerEntry const*
+    operator->() const
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::operator-> : entry does not exist");
+        return sle_.get();
+    }
+
+    STLedgerEntry const&
+    operator*() const
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::operator* : entry does not exist");
+        return *sle_;
+    }
+
+    // --- Writable interface (compile-time gated) ---
+    //
+    // Everything that hands out mutable access (or mutates) is non-const, so
+    // that a `WFooEntry const&` is as inert as a `RFooEntry`. Use readView()
+    // when a const entry only needs to inspect the view.
+
+    /**
+     * Returns the underlying SLE for write access.
+     *
+     * Prefer operator-> / operator* for field access; this is for the call
+     * sites that need the shared_ptr itself.
+     */
+    [[nodiscard]] sle_ptr_type const&
+    mutableRawSle()
+        requires kIsWritable
+    {
+        return sle_;
+    }
+
+    /**
+     * Returns the apply view for write operations
+     */
+    [[nodiscard]] ApplyView&
+    applyView()
+        requires kIsWritable
+    {
+        return view_;
+    }
+
+    /**
+     * Mutable dereference operators
+     *
+     * @throws std::logic_error if exists() is false.
+     */
+    STLedgerEntry*
+    operator->()
+        requires kIsWritable
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::operator-> : entry does not exist");
+        return sle_.get();
+    }
+
+    STLedgerEntry&
+    operator*()
+        requires kIsWritable
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::operator* : entry does not exist");
+        return *sle_;
+    }
+
+    /**
+     * Inserts the entry into the view.
+     *
+     * @throws std::logic_error if exists() is false.
+     */
+    void
+    insert()
+        requires kIsWritable
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::insert : entry does not exist");
+        view_.insert(sle_);
+    }
+
+    /**
+     * Erases the entry from the view.
+     *
+     * Drops the SLE afterwards, so the entry reports !exists() and any
+     * further use trips an assertion here rather than either throwing from
+     * deep inside ApplyStateTable or -- worse -- silently succeeding. For an
+     * entry that already existed, ApplyStateTable::erase keeps holding this
+     * exact SLE and builds the DeletedNode's FinalFields from it, so a write
+     * through the entry after erase() would land in transaction metadata
+     * with no diagnostic at all.
+     *
+     * @throws std::logic_error if exists() is false.
+     */
+    void
+    erase()
+        requires kIsWritable
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::erase : entry does not exist");
+        view_.erase(sle_);
+        sle_ = nullptr;
+    }
+
+    /**
+     * @throws std::logic_error if exists() is false.
+     */
+    void
+    update()
+        requires kIsWritable
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::update : entry does not exist");
+        view_.update(sle_);
+    }
+
+    /**
+     * @throws std::logic_error if exists() is true: newSLE() would otherwise
+     *         silently discard the SLE already held.
+     */
+    void
+    newSLE()
+        requires kIsWritable
+    {
+        if (exists())
+            Throw<std::logic_error>("xrpl::SLEBase::newSLE : entry already exists");
+        sle_ = std::make_shared<SLE>(key_);
+    }
+
+    [[nodiscard]] beast::Journal
+    journal() const
+    {
+        return j_;
+    }
+
+protected:
+    view_ref_type view_;
+
+    // Keylet is only meaningful for writable views, which need it to build an
+    // SLE that does not exist yet; read-only entries derive it from the SLE.
+    struct Empty
+    {
+    };
+    // No default member initializer: Keylet is not default-constructible, so
+    // every writable constructor must initialize key_ explicitly.
+    [[no_unique_address]]
+    std::conditional_t<kIsWritable, Keylet, Empty> key_;
+
+    sle_ptr_type sle_{};
+    beast::Journal j_;
+};
+
+/**
+ * Generic (any-entry-type) SLE entries.
+ *
+ * Use these when the concrete ledger entry type is not known at a given site;
+ * otherwise prefer the per-type entries (e.g. AccountRootEntry.h), which
+ * additionally enforce the entry type at compile time.
+ *
+ *   SLE::const_pointer / SLE::const_ref  ->  ReadOnlySLE
+ *   SLE::pointer       / SLE::ref        ->  WritableSLE
+ */
+using ReadOnlySLE = SLEBase<ReadView>;
+using WritableSLE = SLEBase<ApplyView>;
+
+static_assert(
+    !std::is_polymorphic_v<ReadOnlySLE> && !std::is_polymorphic_v<WritableSLE>,
+    "SLEBase must stay a thin value type; it must not acquire a vtable");
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/SignerListEntry.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class SignerListEntry : public SLEBase<ViewT, ltSIGNER_LIST>
+{
+public:
+    using Base = SLEBase<ViewT, ltSIGNER_LIST>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit SignerListEntry(
+        AccountID const& account,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::signerList(account), view, j)
+    {
+    }
+};
+
+using RSignerListEntry = SignerListEntry<ReadView>;
+using WSignerListEntry = SignerListEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/SponsorshipEntry.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class SponsorshipEntry : public SLEBase<ViewT, ltSPONSORSHIP>
+{
+public:
+    using Base = SLEBase<ViewT, ltSPONSORSHIP>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit SponsorshipEntry(
+        AccountID const& sponsor,
+        AccountID const& sponsee,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::sponsorship(sponsor, sponsee), view, j)
+    {
+    }
+};
+
+using RSponsorshipEntry = SponsorshipEntry<ReadView>;
+using WSponsorshipEntry = SponsorshipEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/TicketEntry.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class TicketEntry : public SLEBase<ViewT, ltTICKET>
+{
+public:
+    using Base = SLEBase<ViewT, ltTICKET>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit TicketEntry(
+        AccountID const& id,
+        SeqProxy const& ticketSeq,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::ticket(id, ticketSeq), view, j)
+    {
+    }
+
+    explicit TicketEntry(
+        uint256 const& ticketID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::ticket(ticketID), view, j)
+    {
+    }
+};
+
+using RTicketEntry = TicketEntry<ReadView>;
+using WTicketEntry = TicketEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/VaultEntry.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class VaultEntry : public SLEBase<ViewT, ltVAULT>
+{
+public:
+    using Base = SLEBase<ViewT, ltVAULT>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit VaultEntry(
+        AccountID const& owner,
+        SeqProxy const& seq,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::vault(owner, seq), view, j)
+    {
+    }
+
+    explicit VaultEntry(
+        uint256 const& vaultID,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::vault(vaultID), view, j)
+    {
+    }
+};
+
+using RVaultEntry = VaultEntry<ReadView>;
+using WVaultEntry = VaultEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/XChainOwnedClaimIDEntry.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STXChainBridge.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+template <typename ViewT>
+class XChainOwnedClaimIDEntry : public SLEBase<ViewT, ltXCHAIN_OWNED_CLAIM_ID>
+{
+public:
+    using Base = SLEBase<ViewT, ltXCHAIN_OWNED_CLAIM_ID>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit XChainOwnedClaimIDEntry(
+        STXChainBridge const& bridge,
+        std::uint64_t seq,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::xChainClaimID(bridge, seq), view, j)
+    {
+    }
+};
+
+using RXChainOwnedClaimIDEntry = XChainOwnedClaimIDEntry<ReadView>;
+using WXChainOwnedClaimIDEntry = XChainOwnedClaimIDEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/XChainOwnedCreateAccountClaimIDEntry.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STXChainBridge.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+template <typename ViewT>
+class XChainOwnedCreateAccountClaimIDEntry
+    : public SLEBase<ViewT, ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID>
+{
+public:
+    using Base = SLEBase<ViewT, ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit XChainOwnedCreateAccountClaimIDEntry(
+        STXChainBridge const& bridge,
+        std::uint64_t seq,
+        Base::view_ref_type view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::xChainCreateAccountClaimID(bridge, seq), view, j)
+    {
+    }
+};
+
+using RXChainOwnedCreateAccountClaimIDEntry = XChainOwnedCreateAccountClaimIDEntry<ReadView>;
+using WXChainOwnedCreateAccountClaimIDEntry = XChainOwnedCreateAccountClaimIDEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/protocol/AMMCore.h

@@ -91,6 +91,17 @@ getFee(std::uint16_t tfee)
     return Number{tfee} / kAuctionSlotFeeScaleFactor;
 }
 
+/**
+ * Minimum auction slot price: LPTokens * TradingFee / kAuctionSlotMinFeeFraction
+ * @param lptAMMBalance  AMM LP token balance
+ * @param tradingFee     trading fee in {0, 1000}
+ */
+inline Number
+ammAuctionMinSlotPrice(Number const& lptAMMBalance, std::uint16_t tradingFee)
+{
+    return lptAMMBalance * getFee(tradingFee) / kAuctionSlotMinFeeFraction;
+}
+
 /**
  * Get fee multiplier (1 - tfee)
  * @tfee trading fee in basis points

include/xrpl/protocol/Permissions.h

@@ -4,6 +4,7 @@
 #include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/SOTemplate.h>
 #include <xrpl/protocol/TxFormats.h>
+#include <xrpl/protocol/TxSettings.h>
 
 #include <cstdint>
 #include <functional>
@@ -38,11 +39,6 @@ enum GranularPermissionType : std::uint32_t {
 #pragma pop_macro("GRANULAR_PERMISSION")
 };
 
-// Injected bare enumerators (xrpl::delegable / xrpl::notDelegable) are required by preprocessor
-// tricks in tests and macro-generated code; enum class would break that.
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-enum Delegation { Delegable, NotDelegable };
-
 class Permission
 {
 private:
@@ -65,7 +61,7 @@ private:
     struct TxDelegationEntry
     {
         uint256 amendment;
-        Delegation delegable{NotDelegable};
+        Delegation delegable{Delegation::NotDelegable};
     };
 
     std::unordered_set<TxType> granularTxTypes_;

include/xrpl/protocol/TxSettings.h

@@ -0,0 +1,96 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/safe_cast.h>
+
+#include <cstdint>
+#include <type_traits>
+
+namespace xrpl {
+
+enum class Delegation { Delegable, NotDelegable };
+
+/**
+ * Operations a transaction is permitted to perform, as a bitfield.
+ *
+ * These are declared per-transaction in transactions.macro (via
+ * TxSettings::privileges) and enforced in InvariantCheck.cpp.
+ */
+enum class Privilege : std::uint16_t {
+    NoPriv = 0x0000,              // The transaction can not do any of the enumerated operations
+    CreateAcct = 0x0001,          // The transaction can create a new ACCOUNT_ROOT object.
+    CreatePseudoAcct = 0x0002,    // The transaction can create a pseudo account,
+                                  // which implies createAcct
+    MustDeleteAcct = 0x0004,      // The transaction must delete an ACCOUNT_ROOT object
+    MayDeleteAcct = 0x0008,       // The transaction may delete an ACCOUNT_ROOT
+                                  // object, but does not have to
+    OverrideFreeze = 0x0010,      // The transaction can override some freeze rules
+    ChangeNftCounts = 0x0020,     // The transaction can mint or burn an NFT
+    CreateMptIssuance = 0x0040,   // The transaction can create a new MPT issuance
+    DestroyMptIssuance = 0x0080,  // The transaction can destroy an MPT issuance
+    MustAuthorizeMpt = 0x0100,    // The transaction MUST create or delete an MPT
+                                  // object (except by issuer)
+    MayAuthorizeMpt = 0x0200,     // The transaction MAY create or delete an MPT
+                                  // object (except by issuer)
+    MayDeleteMpt = 0x0400,        // The transaction MAY delete an MPT object. May not create.
+    MustModifyVault = 0x0800,     // The transaction must modify, delete or create, a vault
+    MayModifyVault = 0x1000,      // The transaction MAY modify, delete or create, a vault
+    MayCreateMpt = 0x2000,        // The transaction MAY create an MPT object, except for issuer.
+};
+
+// The inner static_cast is not redundant: the underlying type is narrower than
+// `int`, so the operands integer-promote and the result has to be narrowed back.
+// safeCast rejects that narrowing, but every input bit is a Privilege bit by
+// construction, so the result is always representable.
+constexpr Privilege
+operator|(Privilege lhs, Privilege rhs)
+{
+    using Underlying = std::underlying_type_t<Privilege>;
+    return static_cast<Privilege>(
+        static_cast<Underlying>(safeCast<Underlying>(lhs) | safeCast<Underlying>(rhs)));
+}
+
+constexpr Privilege
+operator&(Privilege lhs, Privilege rhs)
+{
+    using Underlying = std::underlying_type_t<Privilege>;
+    return static_cast<Privilege>(
+        static_cast<Underlying>(safeCast<Underlying>(lhs) & safeCast<Underlying>(rhs)));
+}
+
+/**
+ * Per-transaction metadata declared in transactions.macro.
+ *
+ * Every member has a default, so a transaction only needs to name the settings
+ * that differ from the common case. See the documentation at the top of
+ * transactions.macro for the authoring syntax.
+ *
+ * This is deliberately not a constexpr-friendly type: amendment identifiers are
+ * runtime-initialized `extern uint256 const` globals (see Feature.h), so a
+ * TxSettings can only be built at runtime.
+ */
+struct TxSettings
+{
+    /**
+     * Whether an account may delegate this transaction to another account.
+     */
+    Delegation delegable{Delegation::NotDelegable};
+
+    /**
+     * The amendment gating this transaction, or uint256{} if always available.
+     */
+    // The `{}` looks redundant, because BaseUInt's default constructor already
+    // zeroes the value. It is not: without a default member initializer here,
+    // every partial designated initializer in transactions.macro trips the
+    // missing-designated-field-initializers warning, which the build treats as
+    // an error.
+    // NOLINTNEXTLINE(readability-redundant-member-init)
+    uint256 amendment{};
+
+    /**
+     * Operations this transaction is permitted to perform.
+     */
+    Privilege privileges{Privilege::NoPriv};
+};
+
+}  // namespace xrpl

include/xrpl/protocol_autogen/transactions/AMMBid.h

@@ -21,7 +21,7 @@ class AMMBidBuilder;
  * Type: ttAMM_BID (39)
  * Delegable: Delegation::Delegable
  * Amendment: featureAMM
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use AMMBidBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/AMMClawback.h

@@ -21,7 +21,7 @@ class AMMClawbackBuilder;
  * Type: ttAMM_CLAWBACK (31)
  * Delegable: Delegation::Delegable
  * Amendment: featureAMMClawback
- * Privileges: MayDeleteAcct | OverrideFreeze | MayAuthorizeMpt
+ * Privileges: Privilege::MayDeleteAcct | Privilege::OverrideFreeze | Privilege::MayAuthorizeMpt
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use AMMClawbackBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/AMMCreate.h

@@ -21,7 +21,7 @@ class AMMCreateBuilder;
  * Type: ttAMM_CREATE (35)
  * Delegable: Delegation::Delegable
  * Amendment: featureAMM
- * Privileges: CreatePseudoAcct | MayCreateMpt
+ * Privileges: Privilege::CreatePseudoAcct | Privilege::MayCreateMpt
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use AMMCreateBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/AMMDelete.h

@@ -21,7 +21,7 @@ class AMMDeleteBuilder;
  * Type: ttAMM_DELETE (40)
  * Delegable: Delegation::Delegable
  * Amendment: featureAMM
- * Privileges: MustDeleteAcct | MayDeleteMpt
+ * Privileges: Privilege::MustDeleteAcct | Privilege::MayDeleteMpt
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use AMMDeleteBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/AMMDeposit.h

@@ -21,7 +21,7 @@ class AMMDepositBuilder;
  * Type: ttAMM_DEPOSIT (36)
  * Delegable: Delegation::Delegable
  * Amendment: featureAMM
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use AMMDepositBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/AMMVote.h

@@ -21,7 +21,7 @@ class AMMVoteBuilder;
  * Type: ttAMM_VOTE (38)
  * Delegable: Delegation::Delegable
  * Amendment: featureAMM
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use AMMVoteBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/AMMWithdraw.h

@@ -21,7 +21,7 @@ class AMMWithdrawBuilder;
  * Type: ttAMM_WITHDRAW (37)
  * Delegable: Delegation::Delegable
  * Amendment: featureAMM
- * Privileges: MayDeleteAcct | MayAuthorizeMpt
+ * Privileges: Privilege::MayDeleteAcct | Privilege::MayAuthorizeMpt
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use AMMWithdrawBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/AccountDelete.h

@@ -21,7 +21,7 @@ class AccountDeleteBuilder;
  * Type: ttACCOUNT_DELETE (21)
  * Delegable: Delegation::NotDelegable
  * Amendment: uint256{}
- * Privileges: MustDeleteAcct
+ * Privileges: Privilege::MustDeleteAcct
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use AccountDeleteBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/AccountSet.h

@@ -21,7 +21,7 @@ class AccountSetBuilder;
  * Type: ttACCOUNT_SET (3)
  * Delegable: Delegation::NotDelegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use AccountSetBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/Batch.h

@@ -21,7 +21,7 @@ class BatchBuilder;
  * Type: ttBATCH (71)
  * Delegable: Delegation::NotDelegable
  * Amendment: featureBatchV1_1
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use BatchBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/CheckCancel.h

@@ -21,7 +21,7 @@ class CheckCancelBuilder;
  * Type: ttCHECK_CANCEL (18)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use CheckCancelBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/CheckCash.h

@@ -21,7 +21,7 @@ class CheckCashBuilder;
  * Type: ttCHECK_CASH (17)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: MayCreateMpt
+ * Privileges: Privilege::MayCreateMpt
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use CheckCashBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/CheckCreate.h

@@ -21,7 +21,7 @@ class CheckCreateBuilder;
  * Type: ttCHECK_CREATE (16)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use CheckCreateBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/Clawback.h

@@ -21,7 +21,7 @@ class ClawbackBuilder;
  * Type: ttCLAWBACK (30)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use ClawbackBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/ConfidentialMPTClawback.h

@@ -21,7 +21,7 @@ class ConfidentialMPTClawbackBuilder;
  * Type: ttCONFIDENTIAL_MPT_CLAWBACK (89)
  * Delegable: Delegation::Delegable
  * Amendment: featureConfidentialTransfer
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use ConfidentialMPTClawbackBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/ConfidentialMPTConvert.h

@@ -21,7 +21,7 @@ class ConfidentialMPTConvertBuilder;
  * Type: ttCONFIDENTIAL_MPT_CONVERT (85)
  * Delegable: Delegation::NotDelegable
  * Amendment: featureConfidentialTransfer
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use ConfidentialMPTConvertBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/ConfidentialMPTConvertBack.h

@@ -21,7 +21,7 @@ class ConfidentialMPTConvertBackBuilder;
  * Type: ttCONFIDENTIAL_MPT_CONVERT_BACK (87)
  * Delegable: Delegation::Delegable
  * Amendment: featureConfidentialTransfer
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use ConfidentialMPTConvertBackBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/ConfidentialMPTMergeInbox.h

@@ -21,7 +21,7 @@ class ConfidentialMPTMergeInboxBuilder;
  * Type: ttCONFIDENTIAL_MPT_MERGE_INBOX (86)
  * Delegable: Delegation::Delegable
  * Amendment: featureConfidentialTransfer
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use ConfidentialMPTMergeInboxBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/ConfidentialMPTSend.h

@@ -21,7 +21,7 @@ class ConfidentialMPTSendBuilder;
  * Type: ttCONFIDENTIAL_MPT_SEND (88)
  * Delegable: Delegation::Delegable
  * Amendment: featureConfidentialTransfer
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use ConfidentialMPTSendBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/CredentialAccept.h

@@ -21,7 +21,7 @@ class CredentialAcceptBuilder;
  * Type: ttCREDENTIAL_ACCEPT (59)
  * Delegable: Delegation::Delegable
  * Amendment: featureCredentials
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use CredentialAcceptBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/CredentialCreate.h

@@ -21,7 +21,7 @@ class CredentialCreateBuilder;
  * Type: ttCREDENTIAL_CREATE (58)
  * Delegable: Delegation::Delegable
  * Amendment: featureCredentials
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use CredentialCreateBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/CredentialDelete.h

@@ -21,7 +21,7 @@ class CredentialDeleteBuilder;
  * Type: ttCREDENTIAL_DELETE (60)
  * Delegable: Delegation::Delegable
  * Amendment: featureCredentials
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use CredentialDeleteBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/DIDDelete.h

@@ -21,7 +21,7 @@ class DIDDeleteBuilder;
  * Type: ttDID_DELETE (50)
  * Delegable: Delegation::Delegable
  * Amendment: featureDID
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use DIDDeleteBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/DIDSet.h

@@ -21,7 +21,7 @@ class DIDSetBuilder;
  * Type: ttDID_SET (49)
  * Delegable: Delegation::Delegable
  * Amendment: featureDID
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use DIDSetBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/DelegateSet.h

@@ -21,7 +21,7 @@ class DelegateSetBuilder;
  * Type: ttDELEGATE_SET (64)
  * Delegable: Delegation::NotDelegable
  * Amendment: featurePermissionDelegationV1_1
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use DelegateSetBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/DepositPreauth.h

@@ -21,7 +21,7 @@ class DepositPreauthBuilder;
  * Type: ttDEPOSIT_PREAUTH (19)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use DepositPreauthBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/EnableAmendment.h

@@ -21,7 +21,7 @@ class EnableAmendmentBuilder;
  * Type: ttAMENDMENT (100)
  * Delegable: Delegation::NotDelegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use EnableAmendmentBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/EscrowCancel.h

@@ -21,7 +21,7 @@ class EscrowCancelBuilder;
  * Type: ttESCROW_CANCEL (4)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use EscrowCancelBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/EscrowCreate.h

@@ -21,7 +21,7 @@ class EscrowCreateBuilder;
  * Type: ttESCROW_CREATE (1)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use EscrowCreateBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/EscrowFinish.h

@@ -21,7 +21,7 @@ class EscrowFinishBuilder;
  * Type: ttESCROW_FINISH (2)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use EscrowFinishBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/LedgerStateFix.h

@@ -21,7 +21,7 @@ class LedgerStateFixBuilder;
  * Type: ttLEDGER_STATE_FIX (53)
  * Delegable: Delegation::Delegable
  * Amendment: fixNFTokenPageLinks
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use LedgerStateFixBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/LoanBrokerCoverClawback.h

@@ -21,7 +21,7 @@ class LoanBrokerCoverClawbackBuilder;
  * Type: ttLOAN_BROKER_COVER_CLAWBACK (78)
  * Delegable: Delegation::NotDelegable
  * Amendment: featureLendingProtocol
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use LoanBrokerCoverClawbackBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/LoanBrokerCoverDeposit.h

@@ -21,7 +21,7 @@ class LoanBrokerCoverDepositBuilder;
  * Type: ttLOAN_BROKER_COVER_DEPOSIT (76)
  * Delegable: Delegation::NotDelegable
  * Amendment: featureLendingProtocol
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use LoanBrokerCoverDepositBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/LoanBrokerCoverWithdraw.h

@@ -21,7 +21,7 @@ class LoanBrokerCoverWithdrawBuilder;
  * Type: ttLOAN_BROKER_COVER_WITHDRAW (77)
  * Delegable: Delegation::NotDelegable
  * Amendment: featureLendingProtocol
- * Privileges: MayAuthorizeMpt
+ * Privileges: Privilege::MayAuthorizeMpt
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use LoanBrokerCoverWithdrawBuilder to construct new transactions.
@@ -121,6 +121,32 @@ public:
     {
         return this->tx_->isFieldPresent(sfDestinationTag);
     }
+
+    /**
+     * @brief Get sfCredentialIDs (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VECTOR256::type::value_type>
+    getCredentialIDs() const
+    {
+        if (hasCredentialIDs())
+        {
+            return this->tx_->at(sfCredentialIDs);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfCredentialIDs is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasCredentialIDs() const
+    {
+        return this->tx_->isFieldPresent(sfCredentialIDs);
+    }
 };
 
 /**
@@ -214,6 +240,17 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfCredentialIDs (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerCoverWithdrawBuilder&
+    setCredentialIDs(std::decay_t<typename SF_VECTOR256::type::value_type> const& value)
+    {
+        object_[sfCredentialIDs] = value;
+        return *this;
+    }
+
     /**
      * @brief Build and return the LoanBrokerCoverWithdraw wrapper.
      * @param publicKey The public key for signing.

include/xrpl/protocol_autogen/transactions/LoanBrokerDelete.h

@@ -21,7 +21,7 @@ class LoanBrokerDeleteBuilder;
  * Type: ttLOAN_BROKER_DELETE (75)
  * Delegable: Delegation::NotDelegable
  * Amendment: featureLendingProtocol
- * Privileges: MustDeleteAcct | MayAuthorizeMpt
+ * Privileges: Privilege::MustDeleteAcct | Privilege::MayAuthorizeMpt
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use LoanBrokerDeleteBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/LoanBrokerSet.h

@@ -21,7 +21,7 @@ class LoanBrokerSetBuilder;
  * Type: ttLOAN_BROKER_SET (74)
  * Delegable: Delegation::NotDelegable
  * Amendment: featureLendingProtocol
- * Privileges: CreatePseudoAcct | MayAuthorizeMpt
+ * Privileges: Privilege::CreatePseudoAcct | Privilege::MayAuthorizeMpt
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use LoanBrokerSetBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/LoanDelete.h

@@ -21,7 +21,7 @@ class LoanDeleteBuilder;
  * Type: ttLOAN_DELETE (81)
  * Delegable: Delegation::NotDelegable
  * Amendment: featureLendingProtocol
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use LoanDeleteBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/LoanManage.h

@@ -21,7 +21,7 @@ class LoanManageBuilder;
  * Type: ttLOAN_MANAGE (82)
  * Delegable: Delegation::NotDelegable
  * Amendment: featureLendingProtocol
- * Privileges: MayModifyVault
+ * Privileges: Privilege::MayModifyVault
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use LoanManageBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/LoanPay.h

@@ -21,7 +21,7 @@ class LoanPayBuilder;
  * Type: ttLOAN_PAY (84)
  * Delegable: Delegation::NotDelegable
  * Amendment: featureLendingProtocol
- * Privileges: MayAuthorizeMpt | MustModifyVault
+ * Privileges: Privilege::MayAuthorizeMpt | Privilege::MustModifyVault
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use LoanPayBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/LoanSet.h

@@ -21,7 +21,7 @@ class LoanSetBuilder;
  * Type: ttLOAN_SET (80)
  * Delegable: Delegation::NotDelegable
  * Amendment: featureLendingProtocol
- * Privileges: MayAuthorizeMpt | MustModifyVault
+ * Privileges: Privilege::MayAuthorizeMpt | Privilege::MustModifyVault
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use LoanSetBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/MPTokenAuthorize.h

@@ -21,7 +21,7 @@ class MPTokenAuthorizeBuilder;
  * Type: ttMPTOKEN_AUTHORIZE (57)
  * Delegable: Delegation::Delegable
  * Amendment: featureMPTokensV1
- * Privileges: MustAuthorizeMpt
+ * Privileges: Privilege::MustAuthorizeMpt
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use MPTokenAuthorizeBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/MPTokenIssuanceCreate.h

@@ -21,7 +21,7 @@ class MPTokenIssuanceCreateBuilder;
  * Type: ttMPTOKEN_ISSUANCE_CREATE (54)
  * Delegable: Delegation::Delegable
  * Amendment: featureMPTokensV1
- * Privileges: CreateMptIssuance
+ * Privileges: Privilege::CreateMptIssuance
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use MPTokenIssuanceCreateBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/MPTokenIssuanceDestroy.h

@@ -21,7 +21,7 @@ class MPTokenIssuanceDestroyBuilder;
  * Type: ttMPTOKEN_ISSUANCE_DESTROY (55)
  * Delegable: Delegation::Delegable
  * Amendment: featureMPTokensV1
- * Privileges: DestroyMptIssuance
+ * Privileges: Privilege::DestroyMptIssuance
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use MPTokenIssuanceDestroyBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/MPTokenIssuanceSet.h

@@ -21,7 +21,7 @@ class MPTokenIssuanceSetBuilder;
  * Type: ttMPTOKEN_ISSUANCE_SET (56)
  * Delegable: Delegation::Delegable
  * Amendment: featureMPTokensV1
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use MPTokenIssuanceSetBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/NFTokenAcceptOffer.h

@@ -21,7 +21,7 @@ class NFTokenAcceptOfferBuilder;
  * Type: ttNFTOKEN_ACCEPT_OFFER (29)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use NFTokenAcceptOfferBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/NFTokenBurn.h

@@ -21,7 +21,7 @@ class NFTokenBurnBuilder;
  * Type: ttNFTOKEN_BURN (26)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: ChangeNftCounts
+ * Privileges: Privilege::ChangeNftCounts
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use NFTokenBurnBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/NFTokenCancelOffer.h

@@ -21,7 +21,7 @@ class NFTokenCancelOfferBuilder;
  * Type: ttNFTOKEN_CANCEL_OFFER (28)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use NFTokenCancelOfferBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/NFTokenCreateOffer.h

@@ -21,7 +21,7 @@ class NFTokenCreateOfferBuilder;
  * Type: ttNFTOKEN_CREATE_OFFER (27)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use NFTokenCreateOfferBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/NFTokenMint.h

@@ -21,7 +21,7 @@ class NFTokenMintBuilder;
  * Type: ttNFTOKEN_MINT (25)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: ChangeNftCounts
+ * Privileges: Privilege::ChangeNftCounts
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use NFTokenMintBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/NFTokenModify.h

@@ -21,7 +21,7 @@ class NFTokenModifyBuilder;
  * Type: ttNFTOKEN_MODIFY (61)
  * Delegable: Delegation::Delegable
  * Amendment: featureDynamicNFT
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use NFTokenModifyBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/OfferCancel.h

@@ -21,7 +21,7 @@ class OfferCancelBuilder;
  * Type: ttOFFER_CANCEL (8)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use OfferCancelBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/OfferCreate.h

@@ -21,7 +21,7 @@ class OfferCreateBuilder;
  * Type: ttOFFER_CREATE (7)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: MayCreateMpt
+ * Privileges: Privilege::MayCreateMpt
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use OfferCreateBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/OracleDelete.h

@@ -21,7 +21,7 @@ class OracleDeleteBuilder;
  * Type: ttORACLE_DELETE (52)
  * Delegable: Delegation::Delegable
  * Amendment: featurePriceOracle
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use OracleDeleteBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/OracleSet.h

@@ -21,7 +21,7 @@ class OracleSetBuilder;
  * Type: ttORACLE_SET (51)
  * Delegable: Delegation::Delegable
  * Amendment: featurePriceOracle
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use OracleSetBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/Payment.h

@@ -21,7 +21,7 @@ class PaymentBuilder;
  * Type: ttPAYMENT (0)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: CreateAcct | MayCreateMpt
+ * Privileges: Privilege::CreateAcct | Privilege::MayCreateMpt
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use PaymentBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/PaymentChannelClaim.h

@@ -21,7 +21,7 @@ class PaymentChannelClaimBuilder;
  * Type: ttPAYCHAN_CLAIM (15)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use PaymentChannelClaimBuilder to construct new transactions.

include/xrpl/protocol_autogen/transactions/PaymentChannelCreate.h

@@ -21,7 +21,7 @@ class PaymentChannelCreateBuilder;
  * Type: ttPAYCHAN_CREATE (13)
  * Delegable: Delegation::Delegable
  * Amendment: uint256{}
- * Privileges: NoPriv
+ * Privileges: Privilege::NoPriv
  *
  * Immutable wrapper around STTx providing type-safe field access.
  * Use PaymentChannelCreateBuilder to construct new transactions.