release: Bump version to 3.2.0-b3

Co-authored-by: Ayaz Salikhov <mathbunnyru@users.noreply.github.com>

.github/scripts/rename/copyright.sh

@@ -76,11 +76,11 @@ fi
 if ! grep -q 'Dev Null' src/test/rpc/ValidatorInfo_test.cpp; then
   echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/rpc/ValidatorInfo_test.cpp)" > src/test/rpc/ValidatorInfo_test.cpp
 fi
-if ! grep -q 'Dev Null' src/xrpld/rpc/handlers/server_info/Manifest.cpp; then
-  echo -e "// Copyright (c) 2019 Dev Null Productions\n\n$(cat src/xrpld/rpc/handlers/server_info/Manifest.cpp)" > src/xrpld/rpc/handlers/server_info/Manifest.cpp
+if ! grep -q 'Dev Null' src/xrpld/rpc/handlers/DoManifest.cpp; then
+  echo -e "// Copyright (c) 2019 Dev Null Productions\n\n$(cat src/xrpld/rpc/handlers/DoManifest.cpp)" > src/xrpld/rpc/handlers/DoManifest.cpp
 fi
-if ! grep -q 'Dev Null' src/xrpld/rpc/handlers/admin/status/ValidatorInfo.cpp; then
-  echo -e "// Copyright (c) 2019 Dev Null Productions\n\n$(cat src/xrpld/rpc/handlers/admin/status/ValidatorInfo.cpp)" > src/xrpld/rpc/handlers/admin/status/ValidatorInfo.cpp
+if ! grep -q 'Dev Null' src/xrpld/rpc/handlers/ValidatorInfo.cpp; then
+  echo -e "// Copyright (c) 2019 Dev Null Productions\n\n$(cat src/xrpld/rpc/handlers/ValidatorInfo.cpp)" > src/xrpld/rpc/handlers/ValidatorInfo.cpp
 fi
 if ! grep -q 'Bougalis' include/xrpl/basics/SlabAllocator.h; then
   echo -e "// Copyright (c) 2022, Nikolaos D. Bougalis <nikb@bougalis.net>\n\n$(cat include/xrpl/basics/SlabAllocator.h)" > include/xrpl/basics/SlabAllocator.h # cspell: ignore Nikolaos Bougalis nikb

.github/workflows/check-pr-commits.yml

@@ -10,4 +10,4 @@ permissions:
 
 jobs:
   check_commits:
-    uses: XRPLF/actions/.github/workflows/check-pr-commits.yml@e2c7f400d1e85ae65dad552fd425169fbacca4a3
+    uses: XRPLF/actions/.github/workflows/check-pr-commits.yml@481048b78b94ac3343d1292b4ef125a813879f2b

.github/workflows/check-pr-title.yml

@@ -11,4 +11,4 @@ on:
 jobs:
   check_title:
     if: ${{ github.event.pull_request.draft != true }}
-    uses: XRPLF/actions/.github/workflows/check-pr-title.yml@a5d8dd35be543365e90a11358447130c8763871d
+    uses: XRPLF/actions/.github/workflows/check-pr-title.yml@e2c7f400d1e85ae65dad552fd425169fbacca4a3

.github/workflows/pre-commit.yml

@@ -14,7 +14,7 @@ on:
 jobs:
   # Call the workflow in the XRPLF/actions repo that runs the pre-commit hooks.
   run-hooks:
-    uses: XRPLF/actions/.github/workflows/pre-commit.yml@9307df762265e15c745ddcdb38a581c989f7f349
+    uses: XRPLF/actions/.github/workflows/pre-commit.yml@e7896f15cc60d0da1a272c77ee5c4026b424f9c7
     with:
       runs_on: ubuntu-latest
       container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-41ec7c1" }'

.github/workflows/publish-docs.yml

@@ -47,7 +47,7 @@ jobs:
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab
+        uses: XRPLF/actions/prepare-runner@2bbc2dc1abeec7bfaa886804ab86871ac201764e
         with:
           enable_ccache: false
 

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

@@ -107,7 +107,7 @@ jobs:
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab
+        uses: XRPLF/actions/prepare-runner@2bbc2dc1abeec7bfaa886804ab86871ac201764e
         with:
           enable_ccache: ${{ inputs.ccache_enabled }}
 

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

@@ -35,7 +35,7 @@ jobs:
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab
+        uses: XRPLF/actions/prepare-runner@2bbc2dc1abeec7bfaa886804ab86871ac201764e
         with:
           enable_ccache: false
 

.github/workflows/upload-conan-deps.yml

@@ -70,7 +70,7 @@ jobs:
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab
+        uses: XRPLF/actions/prepare-runner@2bbc2dc1abeec7bfaa886804ab86871ac201764e
         with:
           enable_ccache: false
 

API-CHANGELOG.md

@@ -34,7 +34,6 @@ This section contains changes targeting a future version.
   - `TRANSACTION_FLAGS`: Maps transaction type names to their supported flags and flag values.
   - `LEDGER_ENTRY_FLAGS`: Maps ledger entry type names to their flags and flag values.
   - `ACCOUNT_SET_FLAGS`: Maps AccountSet flag names (asf flags) to their numeric values.
-- `submit`: Augmented response fields (`accepted`, `applied`, `broadcast`, `queued`, `kept`, `account_sequence_next`, `account_sequence_available`, `open_ledger_cost`, `validated_ledger_index`) are now included in sign-and-submit mode. Previously, these fields were only returned when submitting a binary transaction blob.
 
 ### Bugfixes
 
@@ -89,12 +88,6 @@ This release contains bug fixes only and no API changes.
 
 This release contains bug fixes only and no API changes.
 
-## Unreleased Changes
-
-### Additions and bugfixes
-
-- `submit`: Augmented response fields (`accepted`, `applied`, `broadcast`, `queued`, `kept`, `account_sequence_next`, `account_sequence_available`, `open_ledger_cost`, `validated_ledger_index`) are now included in sign-and-submit mode. Previously, these fields were only returned when submitting a binary transaction blob. ([#6304](https://github.com/XRPLF/rippled/pull/6304))
-
 ## XRP Ledger server version 2.5.0
 
 [Version 2.5.0](https://github.com/XRPLF/rippled/releases/tag/2.5.0) was released on Jun 24, 2025.

src/libxrpl/protocol/BuildInfo.cpp

@@ -23,7 +23,7 @@ namespace {
 //  and follow the format described at http://semver.org/
 //------------------------------------------------------------------------------
 // clang-format off
-char const* const versionString = "3.2.0-b0"
+char const* const versionString = "3.2.0-b3"
     // clang-format on
     ;
 

src/libxrpl/tx/Transactor.cpp

@@ -363,13 +363,6 @@ Transactor::checkFee(PreclaimContext const& ctx, XRPAmount baseFee)
 
     auto const balance = (*sle)[sfBalance].xrp();
 
-    // NOTE: Because preclaim evaluates against a static readview, it
-    // does not reflect fee deductions from other transactions paid by
-    // the same account within the current ledger.
-    // As a result, if an account's balance is over-committed across multiple
-    // transactions, this check may pass optimistically.
-    // The fee shortfall will be handled by the Transactor::reset mechanism,
-    // which caps the fee to the remaining actual balance.
     if (balance < feePaid)
     {
         JLOG(ctx.j.trace()) << "Insufficient balance:" << " balance=" << to_string(balance)

src/libxrpl/tx/transactors/payment/Payment.cpp

@@ -559,23 +559,18 @@ Payment::doApply()
     // This is the total reserve in drops.
     auto const reserve = view().fees().accountReserve(ownerCount);
 
-    // In a delegated payment, the fee payer is the delegated account,
-    // not the source account (account_).
-    bool const accountIsPayer = (ctx_.tx.getFeePayer() == account_);
+    // preFeeBalance_ is the balance on the sending account BEFORE the
+    // fees were charged. We want to make sure we have enough reserve
+    // to send. Allow final spend to use reserve for fee.
+    auto const mmm = std::max(reserve, ctx_.tx.getFieldAmount(sfFee).xrp());
 
-    // preFeeBalance_ is the balance on the source account (account_) BEFORE the fees
-    // were charged. If source account is the fee payer, it must also cover the fee.
-    // The final spend may use the reserve to cover fees.
-    auto const minRequiredFunds =
-        accountIsPayer ? std::max(reserve, ctx_.tx.getFieldAmount(sfFee).xrp()) : reserve;
-
-    if (preFeeBalance_ < dstAmount.xrp() + minRequiredFunds)
+    if (preFeeBalance_ < dstAmount.xrp() + mmm)
     {
         // Vote no. However the transaction might succeed, if applied in
         // a different order.
         JLOG(j_.trace()) << "Delay transaction: Insufficient funds: " << to_string(preFeeBalance_)
-                         << " / " << to_string(dstAmount.xrp() + minRequiredFunds) << " ("
-                         << to_string(reserve) << ")";
+                         << " / " << to_string(dstAmount.xrp() + mmm) << " (" << to_string(reserve)
+                         << ")";
 
         return tecUNFUNDED_PAYMENT;
     }

src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp

@@ -43,10 +43,10 @@ VaultWithdraw::preclaim(PreclaimContext const& ctx)
     if (!vault)
         return tecNO_ENTRY;
 
-    auto const amount = ctx.tx[sfAmount];
+    auto const assets = ctx.tx[sfAmount];
     auto const vaultAsset = vault->at(sfAsset);
     auto const vaultShare = vault->at(sfShareMPTID);
-    if (amount.asset() != vaultAsset && amount.asset() != vaultShare)
+    if (assets.asset() != vaultAsset && assets.asset() != vaultShare)
         return tecWRONG_ASSET;
 
     auto const& vaultAccount = vault->at(sfAccount);
@@ -67,53 +67,8 @@ VaultWithdraw::preclaim(PreclaimContext const& ctx)
         // LCOV_EXCL_STOP
     }
 
-    if (ctx.view.rules().enabled(fixSecurity3_1_3) && amount.asset() == vaultShare)
-    {
-        // Post-fixSecurity3_1_3: if the user specified shares, convert
-        // to the equivalent asset amount before checking withdrawal
-        // limits. Pre-amendment the limit check was skipped for
-        // share-denominated withdrawals.
-        auto const sleIssuance = ctx.view.read(keylet::mptIssuance(vaultShare));
-        if (!sleIssuance)
-        {
-            // LCOV_EXCL_START
-            JLOG(ctx.j.error()) << "VaultWithdraw: missing issuance of vault shares.";
-            return tefINTERNAL;
-            // LCOV_EXCL_STOP
-        }
-
-        try
-        {
-            auto const maybeAssets = sharesToAssetsWithdraw(vault, sleIssuance, amount);
-            if (!maybeAssets)
-                return tefINTERNAL;  // LCOV_EXCL_LINE
-
-            if (auto const ret = canWithdraw(
-                    ctx.view,
-                    account,
-                    dstAcct,
-                    *maybeAssets,
-                    ctx.tx.isFieldPresent(sfDestinationTag)))
-                return ret;
-        }
-        catch (std::overflow_error const&)
-        {
-            // It's easy to hit this exception from Number with large enough Scale
-            // so we avoid spamming the log and only use debug here.
-            JLOG(ctx.j.debug())  //
-                << "VaultWithdraw: overflow error with"
-                << " scale=" << (int)vault->at(sfScale)  //
-                << ", assetsTotal=" << vault->at(sfAssetsTotal)
-                << ", sharesTotal=" << sleIssuance->at(sfOutstandingAmount)
-                << ", amount=" << amount.value();
-            return tecPATH_DRY;
-        }
-    }
-    else
-    {
-        if (auto const ret = canWithdraw(ctx.view, ctx.tx))
-            return ret;
-    }
+    if (auto const ret = canWithdraw(ctx.view, ctx.tx))
+        return ret;
 
     // If sending to Account (i.e. not a transfer), we will also create (only
     // if authorized) a trust line or MPToken as needed, in doApply().

src/test/app/Delegate_test.cpp

@@ -274,42 +274,37 @@ class Delegate_test : public beast::unit_test::suite
         testcase("test fee");
         using namespace jtx;
 
-        // Common setup: fund alice, bob, carol with 1000 XRP.
-        auto setup = [&](Env& env) {
-            Account const alice{"alice"};
-            Account const bob{"bob"};
-            Account const carol{"carol"};
-            env.fund(XRP(1000), alice, bob, carol);
-            env.close();
-            return std::make_tuple(alice, bob, carol);
-        };
+        Env env(*this);
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        Account const carol{"carol"};
+        env.fund(XRP(10000), alice, carol);
+        env.fund(XRP(1000), bob);
+        env.close();
 
-        // No fee deduction for terNO_DELEGATE_PERMISSION.
         {
-            Env env(*this);
-            auto [alice, bob, carol] = setup(env);
+            auto aliceBalance = env.balance(alice);
+            auto bobBalance = env.balance(bob);
+            auto carolBalance = env.balance(carol);
 
-            auto const aliceBalance = env.balance(alice);
-            auto const bobBalance = env.balance(bob);
-            auto const carolBalance = env.balance(carol);
-
-            env(pay(alice, carol, XRP(100)), delegate::as(bob), ter(terNO_DELEGATE_PERMISSION));
+            env(pay(alice, carol, XRP(100)),
+                fee(XRP(2000)),
+                delegate::as(bob),
+                ter(terNO_DELEGATE_PERMISSION));
             env.close();
             BEAST_EXPECT(env.balance(alice) == aliceBalance);
             BEAST_EXPECT(env.balance(bob) == bobBalance);
             BEAST_EXPECT(env.balance(carol) == carolBalance);
         }
 
-        // Delegate pays the fee successfully.
-        {
-            Env env(*this);
-            auto [alice, bob, carol] = setup(env);
-            env(delegate::set(alice, bob, {"Payment"}));
-            env.close();
+        env(delegate::set(alice, bob, {"Payment"}));
+        env.close();
 
-            auto const aliceBalance = env.balance(alice);
-            auto const bobBalance = env.balance(bob);
-            auto const carolBalance = env.balance(carol);
+        {
+            // Delegate pays the fee
+            auto aliceBalance = env.balance(alice);
+            auto bobBalance = env.balance(bob);
+            auto carolBalance = env.balance(carol);
 
             auto const sendAmt = XRP(100);
             auto const feeAmt = XRP(10);
@@ -320,16 +315,11 @@ class Delegate_test : public beast::unit_test::suite
             BEAST_EXPECT(env.balance(carol) == carolBalance + sendAmt);
         }
 
-        // Bob has insufficient balance to pay the fee, will get terINSUF_FEE_B.
         {
-            Env env(*this);
-            auto [alice, bob, carol] = setup(env);
-            env(delegate::set(alice, bob, {"Payment"}));
-            env.close();
-
-            auto const aliceBalance = env.balance(alice);
-            auto const bobBalance = env.balance(bob);
-            auto const carolBalance = env.balance(carol);
+            // insufficient balance to pay fee
+            auto aliceBalance = env.balance(alice);
+            auto bobBalance = env.balance(bob);
+            auto carolBalance = env.balance(carol);
 
             env(pay(alice, carol, XRP(100)),
                 fee(XRP(2000)),
@@ -341,143 +331,22 @@ class Delegate_test : public beast::unit_test::suite
             BEAST_EXPECT(env.balance(carol) == carolBalance);
         }
 
-        // The delegated account has enough balance to pay and delegator has enough reserve
         {
-            // Common setup: fund accounts and grant Bob permission to pay on Alice's behalf.
-            // Alice is funded with exactly (paymentAmount + reserve + baseFee): baseFee covers
-            // the DelegateSet tx cost, leaving Alice with exactly (paymentAmount + reserve).
-            // highFee = reserve + baseFee, strictly greater than reserve, so that
-            // max(reserve, highFee) = highFee — making the direct payment check fail.
-            auto setup = [&](Env& env) {
-                Account const alice{"alice"};
-                Account const bob{"bob"};
-                Account const carol{"carol"};
+            // fee is paid by Delegate
+            // on context reset (tec error)
+            auto aliceBalance = env.balance(alice);
+            auto bobBalance = env.balance(bob);
+            auto carolBalance = env.balance(carol);
+            auto const feeAmt = XRP(10);
 
-                auto const baseFee = env.current()->fees().base;
-                auto const reserve = env.current()->fees().accountReserve(1);
-                auto const paymentAmount = XRP(1);
-                auto const highFee = reserve + baseFee;
-                BEAST_EXPECT(highFee > reserve);
-
-                env.fund(paymentAmount + reserve + baseFee, alice);
-                env.fund(XRP(1000), bob);
-                env.fund(XRP(1000), carol);
-                env.close();
-
-                env(delegate::set(alice, bob, {"Payment"}));
-                env.close();
-
-                env.require(balance(alice, paymentAmount + reserve));
-
-                return std::make_tuple(alice, bob, carol, paymentAmount, highFee, reserve);
-            };
-
-            // Alice's balance (paymentAmount + reserve) is insufficient to cover both
-            // the payment and highFee directly. Even though fees are allowed to dip
-            // below reserve, when Alice pays the fee herself the required funds =
-            // paymentAmount + max(reserve, highFee) = paymentAmount + highFee
-            // (since highFee > reserve), which still exceeds her balance.
-            // tec: highFee is consumed from Alice's balance.
-            {
-                Env env(*this);
-                auto [alice, bob, carol, paymentAmount, highFee, reserve] = setup(env);
-                auto const aliceBalance = env.balance(alice);
-                auto const bobBalance = env.balance(bob);
-                auto const carolBalance = env.balance(carol);
-
-                env(pay(alice, carol, paymentAmount), fee(highFee), ter(tecUNFUNDED_PAYMENT));
-
-                // tec consumes the fee from Alice; carol and bob are unaffected.
-                BEAST_EXPECT(env.balance(alice) == aliceBalance - highFee);
-                BEAST_EXPECT(env.balance(bob) == bobBalance);
-                BEAST_EXPECT(env.balance(carol) == carolBalance);
-            }
-
-            // The payment succeeds because the delegated account pays the fee.
-            // Alice only needs (paymentAmount + reserve).
-            {
-                Env env(*this);
-                auto [alice, bob, carol, paymentAmount, highFee, reserve] = setup(env);
-
-                auto const alicePrePay = env.balance(alice, XRP);
-                auto const bobPrePay = env.balance(bob, XRP);
-                auto const carolPrePay = env.balance(carol, XRP);
-
-                env(pay(alice, carol, paymentAmount), delegate::as(bob), fee(highFee));
-                env.close();
-
-                env.require(balance(alice, alicePrePay - paymentAmount));
-                env.require(balance(bob, bobPrePay - highFee));
-                env.require(balance(carol, carolPrePay + paymentAmount));
-            }
-        }
-
-        // Delegated account can pay the fee even if it dips below reserve.
-        {
-            Env env(*this);
-            Account const alice{"alice"};
-            Account const bob{"bob"};
-            Account const carol{"carol"};
-
-            auto const baseFee = env.current()->fees().base;
-            auto const baseReserve = env.current()->fees().accountReserve(0);
-
-            env.fund(env.current()->fees().accountReserve(1) + baseFee + XRP(1), alice);
-            env.fund(baseReserve, bob);
-            env.fund(XRP(1000), carol);
+            env(pay(alice, carol, XRP(20000)),
+                fee(feeAmt),
+                delegate::as(bob),
+                ter(tecUNFUNDED_PAYMENT));
             env.close();
-
-            env(delegate::set(alice, bob, {"Payment"}));
-            env.close();
-
-            auto const alicePreTx = env.balance(alice, XRP);
-            auto const bobPreTx = env.balance(bob, XRP);
-
-            // After paying for this transaction, bob's balance will
-            // dip below the base reserve
-            env(pay(alice, carol, XRP(1)), delegate::as(bob));
-            env.close();
-
-            // Bob's balance is now less than the base reserve.
-            BEAST_EXPECT(env.balance(bob, XRP) < baseReserve);
-            env.require(balance(bob, bobPreTx - drops(baseFee)));
-
-            // Alice's balance only decreased by the 1.0 XRP she sent.
-            env.require(balance(alice, alicePreTx - XRP(1)));
-        }
-
-        // The delegated account has enough balance for the fee, but delegator
-        // runs into tecUNFUNDED_PAYMENT.
-        {
-            Env env(*this);
-            Account const alice{"alice"};
-            Account const bob{"bob"};
-            Account const carol{"carol"};
-
-            auto const baseFee = env.current()->fees().base;
-            auto const reserve = env.current()->fees().accountReserve(1);
-
-            // Alice is funded with (reserve + baseFee): after DelegateSet she has
-            // exactly 'reserve', which is insufficient to send XRP(10) while keeping
-            // reserve. Bob has plenty to pay the fee.
-            env.fund(reserve + baseFee, alice);
-            env.fund(XRP(1000), bob);
-            env.fund(XRP(1000), carol);
-            env.close();
-
-            env(delegate::set(alice, bob, {"Payment"}));
-            env.close();
-
-            auto const alicePrePay = env.balance(alice, XRP);
-            auto const bobPrePay = env.balance(bob, XRP);
-            auto const carolPrePay = env.balance(carol, XRP);
-
-            // Bob pays the fee, but Alice has insufficient balance to send XRP(10).
-            env(pay(alice, carol, XRP(10)), delegate::as(bob), ter(tecUNFUNDED_PAYMENT));
-
-            env.require(balance(alice, alicePrePay));
-            env.require(balance(bob, bobPrePay - drops(baseFee)));
-            env.require(balance(carol, carolPrePay));
+            BEAST_EXPECT(env.balance(alice) == aliceBalance);
+            BEAST_EXPECT(env.balance(bob) == bobBalance - feeAmt);
+            BEAST_EXPECT(env.balance(carol) == carolBalance);
         }
     }
 
@@ -1369,8 +1238,8 @@ class Delegate_test : public beast::unit_test::suite
         // test MPTokenIssuanceUnlock and MPTokenIssuanceLock permissions
         {
             Env env(*this);
-            Account const alice{"alice"};
-            Account const bob{"bob"};
+            Account alice{"alice"};
+            Account bob{"bob"};
             env.fund(XRP(100000), alice, bob);
             env.close();
 
@@ -1416,8 +1285,8 @@ class Delegate_test : public beast::unit_test::suite
         // test mix of granular and transaction level permission
         {
             Env env(*this);
-            Account const alice{"alice"};
-            Account const bob{"bob"};
+            Account alice{"alice"};
+            Account bob{"bob"};
             env.fund(XRP(100000), alice, bob);
             env.close();
 
@@ -1463,8 +1332,8 @@ class Delegate_test : public beast::unit_test::suite
         // tfFullyCanonicalSig won't block delegated transaction
         {
             Env env(*this);
-            Account const alice{"alice"};
-            Account const bob{"bob"};
+            Account alice{"alice"};
+            Account bob{"bob"};
             env.fund(XRP(100000), alice, bob);
             env.close();
 
@@ -1541,9 +1410,11 @@ class Delegate_test : public beast::unit_test::suite
 
         {
             Env env(*this);
+
             Account const alice{"alice"};
             Account const bob{"bob"};
             Account const carol{"carol"};
+
             env.fund(XRP(100000), alice, bob, carol);
             env.close();
 
@@ -1577,9 +1448,11 @@ class Delegate_test : public beast::unit_test::suite
 
         {
             Env env(*this);
+
             Account const alice{"alice"};
             Account const bob{"bob"};
             Account const carol{"carol"};
+
             env.fund(XRP(100000), alice, bob, carol);
             env.close();
 
@@ -1694,8 +1567,8 @@ class Delegate_test : public beast::unit_test::suite
 
         Env env(*this, features);
 
-        Account const alice{"alice"};
-        Account const bob{"bob"};
+        Account alice{"alice"};
+        Account bob{"bob"};
         env.fund(XRP(100000), alice, bob);
         env.close();
 

src/test/app/Vault_test.cpp

@@ -5231,102 +5231,6 @@ class Vault_test : public beast::unit_test::suite
         }
     }
 
-    // Reproduction: canWithdraw IOU limit check bypassed when
-    // withdrawal amount is specified in shares (MPT) rather than in assets.
-    void
-    testBug6_LimitBypassWithShares()
-    {
-        using namespace test::jtx;
-        testcase("Bug6 - limit bypass with share-denominated withdrawal");
-
-        auto const allAmendments = testable_amendments() | featureSingleAssetVault;
-
-        for (auto const& features : {allAmendments, allAmendments - fixSecurity3_1_3})
-        {
-            bool const withFix = features[fixSecurity3_1_3];
-
-            Env env{*this, features};
-            Account const owner{"owner"};
-            Account const issuer{"issuer"};
-            Account const depositor{"depositor"};
-            Account const charlie{"charlie"};
-            Vault const vault{env};
-
-            env.fund(XRP(1000), issuer, owner, depositor, charlie);
-            env(fset(issuer, asfAllowTrustLineClawback));
-            env.close();
-
-            PrettyAsset const asset = issuer["IOU"];
-            env.trust(asset(1000), owner);
-            env.trust(asset(1000), depositor);
-            env(pay(issuer, owner, asset(200)));
-            env(pay(issuer, depositor, asset(200)));
-            env.close();
-
-            // Charlie gets a LOW trustline limit of 5
-            env.trust(asset(5), charlie);
-            env.close();
-
-            auto const [tx, keylet] = vault.create({.owner = owner, .asset = asset});
-            env(tx);
-            env.close();
-
-            auto const depositTx =
-                vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(100)});
-            env(depositTx);
-            env.close();
-
-            // Get the share MPT info
-            auto const vaultSle = env.le(keylet);
-            if (!BEAST_EXPECT(vaultSle))
-                return;
-            auto const mptIssuanceID = vaultSle->at(sfShareMPTID);
-            MPTIssue const shares(mptIssuanceID);
-            PrettyAsset const share(shares);
-
-            // CONTROL: Withdraw 10 IOU (asset-denominated) to charlie.
-            // Charlie's limit is 5, so this should be rejected with tecNO_LINE
-            // regardless of the amendment.
-            {
-                auto withdrawTx =
-                    vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(10)});
-                withdrawTx[sfDestination] = charlie.human();
-                env(withdrawTx, ter{tecNO_LINE});
-                env.close();
-            }
-            auto const charlieBalanceBefore = env.balance(charlie, asset.raw().get<Issue>());
-
-            // Withdraw the equivalent amount in shares to charlie.
-            // Post-fix: rejected (tecNO_LINE) because the share amount is
-            //   converted to assets and the trustline limit is checked.
-            // Pre-fix: succeeds (tesSUCCESS) because the limit check was
-            //   skipped for share-denominated withdrawals.
-            {
-                auto withdrawTx = vault.withdraw(
-                    {.depositor = depositor,
-                     .id = keylet.key,
-                     .amount = STAmount(share, 10'000'000)});
-                withdrawTx[sfDestination] = charlie.human();
-                env(withdrawTx, ter{withFix ? TER{tecNO_LINE} : TER{tesSUCCESS}});
-                env.close();
-
-                auto const charlieBalanceAfter = env.balance(charlie, asset.raw().get<Issue>());
-                if (withFix)
-                {
-                    // Post-fix: charlie's balance is unchanged — the withdrawal
-                    // was correctly rejected despite being share-denominated.
-                    BEAST_EXPECT(charlieBalanceAfter == charlieBalanceBefore);
-                }
-                else
-                {
-                    // Pre-fix: charlie received the assets, bypassing the
-                    // trustline limit.
-                    BEAST_EXPECT(charlieBalanceAfter > charlieBalanceBefore);
-                }
-            }
-        }
-    }
-
 public:
     void
     run() override
@@ -5347,7 +5251,6 @@ public:
         testVaultClawbackBurnShares();
         testVaultClawbackAssets();
         testAssetsMaximum();
-        testBug6_LimitBypassWithShares();
     }
 };
 

src/test/rpc/KeyGeneration_test.cpp

@@ -1,7 +1,7 @@
 #include <test/jtx/TestSuite.h>
 
 #include <xrpld/rpc/detail/RPCHelpers.h>
-#include <xrpld/rpc/handlers/admin/keygen/WalletPropose.h>
+#include <xrpld/rpc/handlers/WalletPropose.h>
 
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/json_writer.h>

src/test/rpc/Submit_test.cpp

@@ -1,96 +0,0 @@
-#include <test/jtx.h>
-
-#include <xrpld/core/ConfigSections.h>
-
-#include <xrpl/protocol/jss.h>
-
-namespace xrpl {
-
-class Submit_test : public beast::unit_test::suite
-{
-public:
-    void
-    testAugmentedFields()
-    {
-        testcase("Augmented fields in sign-and-submit mode");
-
-        using namespace test::jtx;
-
-        // Enable signing support in config
-        Env env{*this, envconfig([](std::unique_ptr<Config> cfg) {
-                    cfg->loadFromString("[" SECTION_SIGNING_SUPPORT "]\ntrue");
-                    return cfg;
-                })};
-
-        Account const alice{"alice"};
-        Account const bob{"bob"};
-
-        env.fund(XRP(10000), alice, bob);
-        env.close();
-
-        // Test 1: Sign-and-submit mode should return augmented fields
-        {
-            Json::Value jv;
-            jv[jss::tx_json][jss::TransactionType] = jss::Payment;
-            jv[jss::tx_json][jss::Account] = alice.human();
-            jv[jss::tx_json][jss::Destination] = bob.human();
-            jv[jss::tx_json][jss::Amount] = XRP(100).value().getJson(JsonOptions::none);
-            jv[jss::secret] = alice.name();
-
-            auto const result = env.rpc("json", "submit", to_string(jv))[jss::result];
-
-            // These are the augmented fields that should be present
-            BEAST_EXPECT(result.isMember(jss::engine_result));
-            BEAST_EXPECT(result.isMember(jss::engine_result_code));
-            BEAST_EXPECT(result.isMember(jss::engine_result_message));
-
-            // New augmented fields from issue #3125
-            BEAST_EXPECT(result.isMember(jss::accepted));
-            BEAST_EXPECT(result.isMember(jss::applied));
-            BEAST_EXPECT(result.isMember(jss::broadcast));
-            BEAST_EXPECT(result.isMember(jss::queued));
-            BEAST_EXPECT(result.isMember(jss::kept));
-
-            // Current ledger state fields
-            BEAST_EXPECT(result.isMember(jss::account_sequence_next));
-            BEAST_EXPECT(result.isMember(jss::account_sequence_available));
-            BEAST_EXPECT(result.isMember(jss::open_ledger_cost));
-            BEAST_EXPECT(result.isMember(jss::validated_ledger_index));
-
-            // Verify basic transaction fields
-            BEAST_EXPECT(result.isMember(jss::tx_blob));
-            BEAST_EXPECT(result.isMember(jss::tx_json));
-        }
-
-        // Test 2: Binary blob mode should also return augmented fields (regression test)
-        {
-            auto jt = env.jt(pay(alice, bob, XRP(100)));
-            Serializer s;
-            jt.stx->add(s);
-
-            auto const result = env.rpc("submit", strHex(s.slice()))[jss::result];
-
-            // Verify augmented fields are present in binary mode too
-            BEAST_EXPECT(result.isMember(jss::engine_result));
-            BEAST_EXPECT(result.isMember(jss::accepted));
-            BEAST_EXPECT(result.isMember(jss::applied));
-            BEAST_EXPECT(result.isMember(jss::broadcast));
-            BEAST_EXPECT(result.isMember(jss::queued));
-            BEAST_EXPECT(result.isMember(jss::kept));
-            BEAST_EXPECT(result.isMember(jss::account_sequence_next));
-            BEAST_EXPECT(result.isMember(jss::account_sequence_available));
-            BEAST_EXPECT(result.isMember(jss::open_ledger_cost));
-            BEAST_EXPECT(result.isMember(jss::validated_ledger_index));
-        }
-    }
-
-    void
-    run() override
-    {
-        testAugmentedFields();
-    }
-};
-
-BEAST_DEFINE_TESTSUITE(Submit, rpc, xrpl);
-
-}  // namespace xrpl

src/xrpld/overlay/detail/OverlayImpl.cpp

@@ -7,7 +7,7 @@
 #include <xrpld/overlay/detail/Tuning.h>
 #include <xrpld/overlay/predicates.h>
 #include <xrpld/peerfinder/make_Manager.h>
-#include <xrpld/rpc/handlers/admin/status/GetCounts.h>
+#include <xrpld/rpc/handlers/GetCounts.h>
 #include <xrpld/rpc/json_body.h>
 
 #include <xrpl/basics/base64.h>

src/xrpld/rpc/detail/Handler.cpp

@@ -1,6 +1,6 @@
 #include <xrpld/rpc/detail/Handler.h>
 #include <xrpld/rpc/handlers/Handlers.h>
-#include <xrpld/rpc/handlers/server_info/Version.h>
+#include <xrpld/rpc/handlers/Version.h>
 
 #include <xrpl/basics/contract.h>
 #include <xrpl/protocol/ApiVersion.h>
@@ -75,7 +75,7 @@ Handler const handlerArray[]{
     {"account_nfts", byRef(&doAccountNFTs), Role::USER, NO_CONDITION},
     {"account_objects", byRef(&doAccountObjects), Role::USER, NO_CONDITION},
     {"account_offers", byRef(&doAccountOffers), Role::USER, NO_CONDITION},
-    {"account_tx", byRef(&doAccountTx), Role::USER, NO_CONDITION},
+    {"account_tx", byRef(&doAccountTxJson), Role::USER, NO_CONDITION},
     {"amm_info", byRef(&doAMMInfo), Role::USER, NO_CONDITION},
     {"blacklist", byRef(&doBlackList), Role::ADMIN, NO_CONDITION},
     {"book_changes", byRef(&doBookChanges), Role::USER, NO_CONDITION},

src/xrpld/rpc/detail/TransactionSign.cpp

@@ -748,8 +748,6 @@ transactionFormatResultImpl(Transaction::pointer tpTrans, unsigned apiVersion)
             jvResult[jss::engine_result] = sToken;
             jvResult[jss::engine_result_code] = tpTrans->getResult();
             jvResult[jss::engine_result_message] = sHuman;
-
-            RPC::populateAugmentedSubmitFields(jvResult, tpTrans);
         }
     }
     catch (std::exception&)
@@ -763,33 +761,6 @@ transactionFormatResultImpl(Transaction::pointer tpTrans, unsigned apiVersion)
 
 //------------------------------------------------------------------------------
 
-void
-populateAugmentedSubmitFields(
-    Json::Value& jvResult,
-    std::shared_ptr<Transaction> const& transaction)
-{
-    auto const submitResult = transaction->getSubmitResult();
-
-    jvResult[jss::accepted] = submitResult.any();
-    jvResult[jss::applied] = submitResult.applied;
-    jvResult[jss::broadcast] = submitResult.broadcast;
-    jvResult[jss::queued] = submitResult.queued;
-    jvResult[jss::kept] = submitResult.kept;
-
-    if (auto currentLedgerState = transaction->getCurrentLedgerState())
-    {
-        jvResult[jss::account_sequence_next] =
-            safe_cast<Json::Value::UInt>(currentLedgerState->accountSeqNext);
-        jvResult[jss::account_sequence_available] =
-            safe_cast<Json::Value::UInt>(currentLedgerState->accountSeqAvail);
-        jvResult[jss::open_ledger_cost] = to_string(currentLedgerState->minFeeRequired);
-        jvResult[jss::validated_ledger_index] =
-            safe_cast<Json::Value::UInt>(currentLedgerState->validatedLedger);
-    }
-}
-
-//------------------------------------------------------------------------------
-
 [[nodiscard]] static XRPAmount
 getTxFee(Application const& app, Config const& config, Json::Value tx)
 {

src/xrpld/rpc/detail/TransactionSign.h

@@ -16,20 +16,6 @@ class TxQ;
 
 namespace RPC {
 
-/** Populate augmented submit fields into a JSON result.
-    This helper populates the submit result flags (accepted, applied,
-    broadcast, queued, kept) and current ledger state fields
-    (account_sequence_next, account_sequence_available, open_ledger_cost,
-    validated_ledger_index) from a Transaction pointer.
-
-    @param jvResult The JSON result to populate
-    @param transaction The transaction containing the submit result and state
-*/
-void
-populateAugmentedSubmitFields(
-    Json::Value& jvResult,
-    std::shared_ptr<Transaction> const& transaction);
-
 Json::Value
 getCurrentNetworkFee(
     Role const role,

src/xrpld/rpc/handlers/AccountObjects.cpp

@@ -11,11 +11,156 @@
 #include <xrpl/protocol/jss.h>
 #include <xrpl/protocol/nftPageMask.h>
 #include <xrpl/resource/Fees.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 #include <string>
 
 namespace xrpl {
 
+/** General RPC command that can retrieve objects in the account root.
+    {
+      account: <account>
+      ledger_hash: <string> // optional
+      ledger_index: <string | unsigned integer> // optional
+      type: <string> // optional, defaults to all account objects types
+      limit: <integer> // optional
+      marker: <opaque> // optional, resume previous query
+    }
+*/
+
+Json::Value
+doAccountNFTs(RPC::JsonContext& context)
+{
+    auto const& params = context.params;
+    if (!params.isMember(jss::account))
+        return RPC::missing_field_error(jss::account);
+
+    if (!params[jss::account].isString())
+        return RPC::invalid_field_error(jss::account);
+
+    auto id = parseBase58<AccountID>(params[jss::account].asString());
+    if (!id)
+    {
+        return rpcError(rpcACT_MALFORMED);
+    }
+
+    std::shared_ptr<ReadView const> ledger;
+    auto result = RPC::lookupLedger(ledger, context);
+    if (ledger == nullptr)
+        return result;
+    auto const accountID{id.value()};
+
+    if (!ledger->exists(keylet::account(accountID)))
+        return rpcError(rpcACT_NOT_FOUND);
+
+    unsigned int limit = 0;
+    if (auto err = readLimitField(limit, RPC::Tuning::accountNFTokens, context))
+        return *err;
+
+    uint256 marker;
+    bool const markerSet = params.isMember(jss::marker);
+
+    if (markerSet)
+    {
+        auto const& m = params[jss::marker];
+        if (!m.isString())
+            return RPC::expected_field_error(jss::marker, "string");
+
+        if (!marker.parseHex(m.asString()))
+            return RPC::invalid_field_error(jss::marker);
+    }
+
+    auto const first = keylet::nftpage(keylet::nftpage_min(accountID), marker);
+    auto const last = keylet::nftpage_max(accountID);
+
+    auto cp = ledger->read(
+        Keylet(ltNFTOKEN_PAGE, ledger->succ(first.key, last.key.next()).value_or(last.key)));
+
+    std::uint32_t cnt = 0;
+    auto& nfts = (result[jss::account_nfts] = Json::arrayValue);
+
+    // Continue iteration from the current page:
+    bool pastMarker = marker.isZero();
+    bool markerFound = false;
+    uint256 const maskedMarker = marker & nft::pageMask;
+    while (cp)
+    {
+        auto arr = cp->getFieldArray(sfNFTokens);
+
+        for (auto const& o : arr)
+        {
+            // Scrolling past the marker gets weird.  We need to look at
+            // a couple of conditions.
+            //
+            //  1. If the low 96-bits don't match, then we compare only
+            //     against the low 96-bits, since that's what determines
+            //     the sort order of the pages.
+            //
+            //  2. However, within one page there can be a number of
+            //     NFTokenIDs that all have the same low 96 bits.  If we're
+            //     in that case then we need to compare against the full
+            //     256 bits.
+            uint256 const nftokenID = o[sfNFTokenID];
+            uint256 const maskedNftokenID = nftokenID & nft::pageMask;
+
+            if (!pastMarker)
+            {
+                if (maskedNftokenID < maskedMarker)
+                    continue;
+
+                if (maskedNftokenID == maskedMarker && nftokenID < marker)
+                    continue;
+
+                if (nftokenID == marker)
+                {
+                    markerFound = true;
+                    continue;
+                }
+            }
+
+            if (markerSet && !markerFound)
+                return RPC::invalid_field_error(jss::marker);
+
+            pastMarker = true;
+
+            {
+                Json::Value& obj = nfts.append(o.getJson(JsonOptions::none));
+
+                // Pull out the components of the nft ID.
+                obj[sfFlags.jsonName] = nft::getFlags(nftokenID);
+                obj[sfIssuer.jsonName] = to_string(nft::getIssuer(nftokenID));
+                obj[sfNFTokenTaxon.jsonName] = nft::toUInt32(nft::getTaxon(nftokenID));
+                obj[jss::nft_serial] = nft::getSerial(nftokenID);
+                if (std::uint16_t const xferFee = {nft::getTransferFee(nftokenID)})
+                    obj[sfTransferFee.jsonName] = xferFee;
+            }
+
+            if (++cnt == limit)
+            {
+                result[jss::limit] = limit;
+                result[jss::marker] = to_string(o.getFieldH256(sfNFTokenID));
+                return result;
+            }
+        }
+
+        if (auto npm = (*cp)[~sfNextPageMin])
+        {
+            cp = ledger->read(Keylet(ltNFTOKEN_PAGE, *npm));
+        }
+        else
+        {
+            cp = nullptr;
+        }
+    }
+
+    if (markerSet && !markerFound)
+        return RPC::invalid_field_error(jss::marker);
+
+    result[jss::account] = toBase58(accountID);
+    context.loadType = Resource::feeMediumBurdenRPC;
+    return result;
+}
+
 /** Gathers all objects for an account in a ledger.
     @param ledger Ledger to search account objects.
     @param account AccountID to find objects for.

src/xrpld/rpc/handlers/AccountTx.cpp

@@ -364,7 +364,7 @@ populateJsonResponse(
 //   resume previous query
 // }
 Json::Value
-doAccountTx(RPC::JsonContext& context)
+doAccountTxJson(RPC::JsonContext& context)
 {
     if (!context.app.config().useTxTables())
         return rpcError(rpcNOT_ENABLED);

src/xrpld/rpc/handlers/BookOffers.cpp

@@ -1,4 +1,5 @@
 #include <xrpld/app/main/Application.h>
+#include <xrpld/rpc/BookChanges.h>
 #include <xrpld/rpc/Context.h>
 #include <xrpld/rpc/detail/RPCHelpers.h>
 #include <xrpld/rpc/detail/RPCLedgerHelpers.h>
@@ -204,4 +205,16 @@ doBookOffers(RPC::JsonContext& context)
     return jvResult;
 }
 
+Json::Value
+doBookChanges(RPC::JsonContext& context)
+{
+    std::shared_ptr<ReadView const> ledger;
+
+    Json::Value result = RPC::lookupLedger(ledger, context);
+    if (ledger == nullptr)
+        return result;
+
+    return RPC::computeBookChanges(ledger);
+}
+
 }  // namespace xrpl

src/xrpld/rpc/handlers/ChannelVerify.cpp

@@ -1,71 +0,0 @@
-#include <xrpld/rpc/Context.h>
-#include <xrpld/rpc/detail/RPCHelpers.h>
-
-#include <xrpl/basics/StringUtilities.h>
-#include <xrpl/protocol/ErrorCodes.h>
-#include <xrpl/protocol/PayChan.h>
-#include <xrpl/protocol/RPCErr.h>
-#include <xrpl/protocol/jss.h>
-
-#include <optional>
-
-namespace xrpl {
-
-// {
-//   public_key: <public_key>
-//   channel_id: 256-bit channel id
-//   drops: 64-bit uint (as string)
-//   signature: signature to verify
-// }
-Json::Value
-doChannelVerify(RPC::JsonContext& context)
-{
-    auto const& params(context.params);
-    for (auto const& p : {jss::public_key, jss::channel_id, jss::amount, jss::signature})
-    {
-        if (!params.isMember(p))
-            return RPC::missing_field_error(p);
-    }
-
-    std::optional<PublicKey> pk;
-    {
-        std::string const strPk = params[jss::public_key].asString();
-        pk = parseBase58<PublicKey>(TokenType::AccountPublic, strPk);
-
-        if (!pk)
-        {
-            auto pkHex = strUnHex(strPk);
-            if (!pkHex)
-                return rpcError(rpcPUBLIC_MALFORMED);
-            auto const pkType = publicKeyType(makeSlice(*pkHex));
-            if (!pkType)
-                return rpcError(rpcPUBLIC_MALFORMED);
-            pk.emplace(makeSlice(*pkHex));
-        }
-    }
-
-    uint256 channelId;
-    if (!channelId.parseHex(params[jss::channel_id].asString()))
-        return rpcError(rpcCHANNEL_MALFORMED);
-
-    std::optional<std::uint64_t> const optDrops =
-        params[jss::amount].isString() ? to_uint64(params[jss::amount].asString()) : std::nullopt;
-
-    if (!optDrops)
-        return rpcError(rpcCHANNEL_AMT_MALFORMED);
-
-    std::uint64_t const drops = *optDrops;
-
-    auto sig = strUnHex(params[jss::signature].asString());
-    if (!sig || sig->empty())
-        return rpcError(rpcINVALID_PARAMS);
-
-    Serializer msg;
-    serializePayChanAuthorization(msg, channelId, XRPAmount(drops));
-
-    Json::Value result;
-    result[jss::signature_verified] = verify(*pk, msg.slice(), makeSlice(*sig));
-    return result;
-}
-
-}  // namespace xrpl

src/xrpld/rpc/handlers/Handlers.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <xrpld/rpc/handlers/ledger/Ledger.h>
+#include <xrpld/rpc/handlers/LedgerHandler.h>
 
 namespace xrpl {
 
@@ -19,7 +19,7 @@ doAccountObjects(RPC::JsonContext&);
 Json::Value
 doAccountOffers(RPC::JsonContext&);
 Json::Value
-doAccountTx(RPC::JsonContext&);
+doAccountTxJson(RPC::JsonContext&);
 Json::Value
 doAMMInfo(RPC::JsonContext&);
 Json::Value

src/xrpld/rpc/handlers/LedgerEntry.cpp

@@ -1,7 +1,7 @@
 #include <xrpld/rpc/Context.h>
 #include <xrpld/rpc/GRPCHandlers.h>
 #include <xrpld/rpc/detail/RPCLedgerHelpers.h>
-#include <xrpld/rpc/handlers/ledger/LedgerEntryHelpers.h>
+#include <xrpld/rpc/handlers/LedgerEntryHelpers.h>
 
 #include <xrpl/basics/StringUtilities.h>
 #include <xrpl/basics/strHex.h>

src/xrpld/rpc/handlers/LedgerHandler.cpp

@@ -3,7 +3,7 @@
 #include <xrpld/rpc/GRPCHandlers.h>
 #include <xrpld/rpc/Role.h>
 #include <xrpld/rpc/detail/RPCLedgerHelpers.h>
-#include <xrpld/rpc/handlers/ledger/Ledger.h>
+#include <xrpld/rpc/handlers/LedgerHandler.h>
 
 #include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/jss.h>

src/xrpld/rpc/handlers/NFTOffers.cpp

@@ -1,5 +1,3 @@
-#pragma once
-
 #include <xrpld/rpc/Context.h>
 #include <xrpld/rpc/detail/RPCHelpers.h>
 #include <xrpld/rpc/detail/RPCLedgerHelpers.h>
@@ -16,7 +14,7 @@
 
 namespace xrpl {
 
-inline void
+static void
 appendNftOfferJson(
     Application const& app,
     std::shared_ptr<SLE const> const& offer,
@@ -44,7 +42,7 @@ appendNftOfferJson(
 //   limit: integer                 // optional
 //   marker: opaque                 // optional, resume previous query
 // }
-inline Json::Value
+static Json::Value
 enumerateNFTOffers(RPC::JsonContext& context, uint256 const& nftId, Keylet const& directory)
 {
     unsigned int limit = 0;
@@ -129,4 +127,32 @@ enumerateNFTOffers(RPC::JsonContext& context, uint256 const& nftId, Keylet const
     return result;
 }
 
+Json::Value
+doNFTSellOffers(RPC::JsonContext& context)
+{
+    if (!context.params.isMember(jss::nft_id))
+        return RPC::missing_field_error(jss::nft_id);
+
+    uint256 nftId;
+
+    if (!nftId.parseHex(context.params[jss::nft_id].asString()))
+        return RPC::invalid_field_error(jss::nft_id);
+
+    return enumerateNFTOffers(context, nftId, keylet::nft_sells(nftId));
+}
+
+Json::Value
+doNFTBuyOffers(RPC::JsonContext& context)
+{
+    if (!context.params.isMember(jss::nft_id))
+        return RPC::missing_field_error(jss::nft_id);
+
+    uint256 nftId;
+
+    if (!nftId.parseHex(context.params[jss::nft_id].asString()))
+        return RPC::invalid_field_error(jss::nft_id);
+
+    return enumerateNFTOffers(context, nftId, keylet::nft_buys(nftId));
+}
+
 }  // namespace xrpl

src/xrpld/rpc/handlers/PayChanClaim.cpp

@@ -3,6 +3,7 @@
 #include <xrpld/rpc/detail/RPCHelpers.h>
 
 #include <xrpl/basics/StringUtilities.h>
+#include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/PayChan.h>
 #include <xrpl/protocol/RPCErr.h>
@@ -82,4 +83,61 @@ doChannelAuthorize(RPC::JsonContext& context)
     return result;
 }
 
+// {
+//   public_key: <public_key>
+//   channel_id: 256-bit channel id
+//   drops: 64-bit uint (as string)
+//   signature: signature to verify
+// }
+Json::Value
+doChannelVerify(RPC::JsonContext& context)
+{
+    auto const& params(context.params);
+    for (auto const& p : {jss::public_key, jss::channel_id, jss::amount, jss::signature})
+    {
+        if (!params.isMember(p))
+            return RPC::missing_field_error(p);
+    }
+
+    std::optional<PublicKey> pk;
+    {
+        std::string const strPk = params[jss::public_key].asString();
+        pk = parseBase58<PublicKey>(TokenType::AccountPublic, strPk);
+
+        if (!pk)
+        {
+            auto pkHex = strUnHex(strPk);
+            if (!pkHex)
+                return rpcError(rpcPUBLIC_MALFORMED);
+            auto const pkType = publicKeyType(makeSlice(*pkHex));
+            if (!pkType)
+                return rpcError(rpcPUBLIC_MALFORMED);
+            pk.emplace(makeSlice(*pkHex));
+        }
+    }
+
+    uint256 channelId;
+    if (!channelId.parseHex(params[jss::channel_id].asString()))
+        return rpcError(rpcCHANNEL_MALFORMED);
+
+    std::optional<std::uint64_t> const optDrops =
+        params[jss::amount].isString() ? to_uint64(params[jss::amount].asString()) : std::nullopt;
+
+    if (!optDrops)
+        return rpcError(rpcCHANNEL_AMT_MALFORMED);
+
+    std::uint64_t const drops = *optDrops;
+
+    auto sig = strUnHex(params[jss::signature].asString());
+    if (!sig || sig->empty())
+        return rpcError(rpcINVALID_PARAMS);
+
+    Serializer msg;
+    serializePayChanAuthorization(msg, channelId, XRPAmount(drops));
+
+    Json::Value result;
+    result[jss::signature_verified] = verify(*pk, msg.slice(), makeSlice(*sig));
+    return result;
+}
+
 }  // namespace xrpl

src/xrpld/rpc/handlers/Reservations.cpp

@@ -9,6 +9,7 @@
 
 #include <optional>
 #include <string>
+#include <utility>
 
 namespace xrpl {
 
@@ -65,4 +66,46 @@ doPeerReservationsAdd(RPC::JsonContext& context)
     return result;
 }
 
+Json::Value
+doPeerReservationsDel(RPC::JsonContext& context)
+{
+    auto const& params = context.params;
+
+    // We repeat much of the parameter parsing from `doPeerReservationsAdd`.
+    if (!params.isMember(jss::public_key))
+        return RPC::missing_field_error(jss::public_key);
+    if (!params[jss::public_key].isString())
+        return RPC::expected_field_error(jss::public_key, "a string");
+
+    std::optional<PublicKey> optPk =
+        parseBase58<PublicKey>(TokenType::NodePublic, params[jss::public_key].asString());
+    if (!optPk)
+        return rpcError(rpcPUBLIC_MALFORMED);
+    PublicKey const& nodeId = *optPk;
+
+    auto const previous = context.app.getPeerReservations().erase(nodeId);
+
+    Json::Value result{Json::objectValue};
+    if (previous)
+    {
+        result[jss::previous] = previous->toJson();
+    }
+    return result;
+}
+
+Json::Value
+doPeerReservationsList(RPC::JsonContext& context)
+{
+    auto const& reservations = context.app.getPeerReservations().list();
+    // Enumerate the reservations in context.app.getPeerReservations()
+    // as a Json::Value.
+    Json::Value result{Json::objectValue};
+    Json::Value& jaReservations = result[jss::reservations] = Json::arrayValue;
+    for (auto const& reservation : reservations)
+    {
+        jaReservations.append(reservation.toJson());
+    }
+    return result;
+}
+
 }  // namespace xrpl

src/xrpld/rpc/handlers/Submit.cpp

@@ -131,7 +131,24 @@ doSubmit(RPC::JsonContext& context)
             jvResult[jss::engine_result_code] = transaction->getResult();
             jvResult[jss::engine_result_message] = sHuman;
 
-            RPC::populateAugmentedSubmitFields(jvResult, transaction);
+            auto const submitResult = transaction->getSubmitResult();
+
+            jvResult[jss::accepted] = submitResult.any();
+            jvResult[jss::applied] = submitResult.applied;
+            jvResult[jss::broadcast] = submitResult.broadcast;
+            jvResult[jss::queued] = submitResult.queued;
+            jvResult[jss::kept] = submitResult.kept;
+
+            if (auto currentLedgerState = transaction->getCurrentLedgerState())
+            {
+                jvResult[jss::account_sequence_next] =
+                    safe_cast<Json::Value::UInt>(currentLedgerState->accountSeqNext);
+                jvResult[jss::account_sequence_available] =
+                    safe_cast<Json::Value::UInt>(currentLedgerState->accountSeqAvail);
+                jvResult[jss::open_ledger_cost] = to_string(currentLedgerState->minFeeRequired);
+                jvResult[jss::validated_ledger_index] =
+                    safe_cast<Json::Value::UInt>(currentLedgerState->validatedLedger);
+            }
         }
 
         return jvResult;

src/xrpld/rpc/handlers/WalletPropose.cpp

@@ -1,6 +1,6 @@
 #include <xrpld/rpc/Context.h>
 #include <xrpld/rpc/detail/RPCHelpers.h>
-#include <xrpld/rpc/handlers/admin/keygen/WalletPropose.h>
+#include <xrpld/rpc/handlers/WalletPropose.h>
 
 #include <xrpl/basics/strHex.h>
 #include <xrpl/protocol/ErrorCodes.h>

src/xrpld/rpc/handlers/account/AccountNFTs.cpp

@@ -1,160 +0,0 @@
-#include <xrpld/rpc/Context.h>
-#include <xrpld/rpc/detail/RPCHelpers.h>
-#include <xrpld/rpc/detail/RPCLedgerHelpers.h>
-#include <xrpld/rpc/detail/Tuning.h>
-
-#include <xrpl/ledger/ReadView.h>
-#include <xrpl/protocol/ErrorCodes.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/RPCErr.h>
-#include <xrpl/protocol/jss.h>
-#include <xrpl/protocol/nftPageMask.h>
-#include <xrpl/resource/Fees.h>
-#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
-
-namespace xrpl {
-
-/** General RPC command that can retrieve objects in the account root.
-    {
-      account: <account>
-      ledger_hash: <string> // optional
-      ledger_index: <string | unsigned integer> // optional
-      type: <string> // optional, defaults to all account objects types
-      limit: <integer> // optional
-      marker: <opaque> // optional, resume previous query
-    }
-*/
-Json::Value
-doAccountNFTs(RPC::JsonContext& context)
-{
-    auto const& params = context.params;
-    if (!params.isMember(jss::account))
-        return RPC::missing_field_error(jss::account);
-
-    if (!params[jss::account].isString())
-        return RPC::invalid_field_error(jss::account);
-
-    auto id = parseBase58<AccountID>(params[jss::account].asString());
-    if (!id)
-    {
-        return rpcError(rpcACT_MALFORMED);
-    }
-
-    std::shared_ptr<ReadView const> ledger;
-    auto result = RPC::lookupLedger(ledger, context);
-    if (ledger == nullptr)
-        return result;
-    auto const accountID{id.value()};
-
-    if (!ledger->exists(keylet::account(accountID)))
-        return rpcError(rpcACT_NOT_FOUND);
-
-    unsigned int limit = 0;
-    if (auto err = readLimitField(limit, RPC::Tuning::accountNFTokens, context))
-        return *err;
-
-    uint256 marker;
-    bool const markerSet = params.isMember(jss::marker);
-
-    if (markerSet)
-    {
-        auto const& m = params[jss::marker];
-        if (!m.isString())
-            return RPC::expected_field_error(jss::marker, "string");
-
-        if (!marker.parseHex(m.asString()))
-            return RPC::invalid_field_error(jss::marker);
-    }
-
-    auto const first = keylet::nftpage(keylet::nftpage_min(accountID), marker);
-    auto const last = keylet::nftpage_max(accountID);
-
-    auto cp = ledger->read(
-        Keylet(ltNFTOKEN_PAGE, ledger->succ(first.key, last.key.next()).value_or(last.key)));
-
-    std::uint32_t cnt = 0;
-    auto& nfts = (result[jss::account_nfts] = Json::arrayValue);
-
-    // Continue iteration from the current page:
-    bool pastMarker = marker.isZero();
-    bool markerFound = false;
-    uint256 const maskedMarker = marker & nft::pageMask;
-    while (cp)
-    {
-        auto arr = cp->getFieldArray(sfNFTokens);
-
-        for (auto const& o : arr)
-        {
-            // Scrolling past the marker gets weird.  We need to look at
-            // a couple of conditions.
-            //
-            //  1. If the low 96-bits don't match, then we compare only
-            //     against the low 96-bits, since that's what determines
-            //     the sort order of the pages.
-            //
-            //  2. However, within one page there can be a number of
-            //     NFTokenIDs that all have the same low 96 bits.  If we're
-            //     in that case then we need to compare against the full
-            //     256 bits.
-            uint256 const nftokenID = o[sfNFTokenID];
-            uint256 const maskedNftokenID = nftokenID & nft::pageMask;
-
-            if (!pastMarker)
-            {
-                if (maskedNftokenID < maskedMarker)
-                    continue;
-
-                if (maskedNftokenID == maskedMarker && nftokenID < marker)
-                    continue;
-
-                if (nftokenID == marker)
-                {
-                    markerFound = true;
-                    continue;
-                }
-            }
-
-            if (markerSet && !markerFound)
-                return RPC::invalid_field_error(jss::marker);
-
-            pastMarker = true;
-
-            {
-                Json::Value& obj = nfts.append(o.getJson(JsonOptions::none));
-
-                // Pull out the components of the nft ID.
-                obj[sfFlags.jsonName] = nft::getFlags(nftokenID);
-                obj[sfIssuer.jsonName] = to_string(nft::getIssuer(nftokenID));
-                obj[sfNFTokenTaxon.jsonName] = nft::toUInt32(nft::getTaxon(nftokenID));
-                obj[jss::nft_serial] = nft::getSerial(nftokenID);
-                if (std::uint16_t const xferFee = {nft::getTransferFee(nftokenID)})
-                    obj[sfTransferFee.jsonName] = xferFee;
-            }
-
-            if (++cnt == limit)
-            {
-                result[jss::limit] = limit;
-                result[jss::marker] = to_string(o.getFieldH256(sfNFTokenID));
-                return result;
-            }
-        }
-
-        if (auto npm = (*cp)[~sfNextPageMin])
-        {
-            cp = ledger->read(Keylet(ltNFTOKEN_PAGE, *npm));
-        }
-        else
-        {
-            cp = nullptr;
-        }
-    }
-
-    if (markerSet && !markerFound)
-        return RPC::invalid_field_error(jss::marker);
-
-    result[jss::account] = toBase58(accountID);
-    context.loadType = Resource::feeMediumBurdenRPC;
-    return result;
-}
-
-}  // namespace xrpl

src/xrpld/rpc/handlers/admin/peer/PeerReservationsDel.cpp

@@ -1,41 +0,0 @@
-#include <xrpld/rpc/Context.h>
-#include <xrpld/rpc/handlers/Handlers.h>
-
-#include <xrpl/json/json_value.h>
-#include <xrpl/protocol/ErrorCodes.h>
-#include <xrpl/protocol/PublicKey.h>
-#include <xrpl/protocol/RPCErr.h>
-#include <xrpl/protocol/jss.h>
-
-#include <optional>
-
-namespace xrpl {
-
-Json::Value
-doPeerReservationsDel(RPC::JsonContext& context)
-{
-    auto const& params = context.params;
-
-    // We repeat much of the parameter parsing from `doPeerReservationsAdd`.
-    if (!params.isMember(jss::public_key))
-        return RPC::missing_field_error(jss::public_key);
-    if (!params[jss::public_key].isString())
-        return RPC::expected_field_error(jss::public_key, "a string");
-
-    std::optional<PublicKey> optPk =
-        parseBase58<PublicKey>(TokenType::NodePublic, params[jss::public_key].asString());
-    if (!optPk)
-        return rpcError(rpcPUBLIC_MALFORMED);
-    PublicKey const& nodeId = *optPk;
-
-    auto const previous = context.app.getPeerReservations().erase(nodeId);
-
-    Json::Value result{Json::objectValue};
-    if (previous)
-    {
-        result[jss::previous] = previous->toJson();
-    }
-    return result;
-}
-
-}  // namespace xrpl

src/xrpld/rpc/handlers/admin/peer/PeerReservationsList.cpp

@@ -1,24 +0,0 @@
-#include <xrpld/rpc/Context.h>
-#include <xrpld/rpc/handlers/Handlers.h>
-
-#include <xrpl/json/json_value.h>
-#include <xrpl/protocol/jss.h>
-
-namespace xrpl {
-
-Json::Value
-doPeerReservationsList(RPC::JsonContext& context)
-{
-    auto const& reservations = context.app.getPeerReservations().list();
-    // Enumerate the reservations in context.app.getPeerReservations()
-    // as a Json::Value.
-    Json::Value result{Json::objectValue};
-    Json::Value& jaReservations = result[jss::reservations] = Json::arrayValue;
-    for (auto const& reservation : reservations)
-    {
-        jaReservations.append(reservation.toJson());
-    }
-    return result;
-}
-
-}  // namespace xrpl

src/xrpld/rpc/handlers/orderbook/BookChanges.cpp

@@ -1,21 +0,0 @@
-#include <xrpld/rpc/BookChanges.h>
-#include <xrpld/rpc/Context.h>
-#include <xrpld/rpc/detail/RPCLedgerHelpers.h>
-
-#include <xrpl/ledger/ReadView.h>
-
-namespace xrpl {
-
-Json::Value
-doBookChanges(RPC::JsonContext& context)
-{
-    std::shared_ptr<ReadView const> ledger;
-
-    Json::Value result = RPC::lookupLedger(ledger, context);
-    if (ledger == nullptr)
-        return result;
-
-    return RPC::computeBookChanges(ledger);
-}
-
-}  // namespace xrpl

src/xrpld/rpc/handlers/orderbook/NFTBuyOffers.cpp

@@ -1,24 +0,0 @@
-#include <xrpld/rpc/Context.h>
-#include <xrpld/rpc/handlers/orderbook/NFTOffersHelpers.h>
-
-#include <xrpl/protocol/ErrorCodes.h>
-#include <xrpl/protocol/RPCErr.h>
-#include <xrpl/protocol/jss.h>
-
-namespace xrpl {
-
-Json::Value
-doNFTBuyOffers(RPC::JsonContext& context)
-{
-    if (!context.params.isMember(jss::nft_id))
-        return RPC::missing_field_error(jss::nft_id);
-
-    uint256 nftId;
-
-    if (!nftId.parseHex(context.params[jss::nft_id].asString()))
-        return RPC::invalid_field_error(jss::nft_id);
-
-    return enumerateNFTOffers(context, nftId, keylet::nft_buys(nftId));
-}
-
-}  // namespace xrpl

src/xrpld/rpc/handlers/orderbook/NFTSellOffers.cpp

@@ -1,24 +0,0 @@
-#include <xrpld/rpc/Context.h>
-#include <xrpld/rpc/handlers/orderbook/NFTOffersHelpers.h>
-
-#include <xrpl/protocol/ErrorCodes.h>
-#include <xrpl/protocol/RPCErr.h>
-#include <xrpl/protocol/jss.h>
-
-namespace xrpl {
-
-Json::Value
-doNFTSellOffers(RPC::JsonContext& context)
-{
-    if (!context.params.isMember(jss::nft_id))
-        return RPC::missing_field_error(jss::nft_id);
-
-    uint256 nftId;
-
-    if (!nftId.parseHex(context.params[jss::nft_id].asString()))
-        return RPC::invalid_field_error(jss::nft_id);
-
-    return enumerateNFTOffers(context, nftId, keylet::nft_sells(nftId));
-}
-
-}  // namespace xrpl