fix changelog

- Updated Json::Value to json::Value (lowercase namespace)
- Updated safe_cast to safeCast
- Updated constant naming (e.g., defaultAutoFillFeeMultiplier to kDefaultAutoFillFeeMultiplier)
- Merged testAugmentedFields with testFailHardValidation in Submit_test.cpp
- Updated namespace from xrpl to xrpl::test for test files
- Updated beast::unit_test::suite to beast::unit_test::Suite

Co-authored-by: mvadari <8029314+mvadari@users.noreply.github.com>

.cspell.config.yaml

@@ -216,7 +216,6 @@ words:
   - Nyffenegger
   - onlatest
   - ostr
-  - oxalica
   - pargs
   - partitioner
   - paychan

.github/workflows/build-nix-images.yml

@@ -8,7 +8,6 @@ on:
       - ".github/workflows/build-nix-images.yml"
       - "flake.nix"
       - "flake.lock"
-      - "rust-toolchain.toml"
       - "nix/**"
       - "!nix/docker/README.md"
       - "!nix/devshell.nix"
@@ -19,7 +18,6 @@ on:
       - ".github/workflows/build-nix-images.yml"
       - "flake.nix"
       - "flake.lock"
-      - "rust-toolchain.toml"
       - "nix/**"
       - "!nix/docker/README.md"
       - "!nix/devshell.nix"

.gitignore

@@ -81,9 +81,6 @@ DerivedData
 # Python
 __pycache__
 
-# Rust build artifacts.
-target/
-
 # Direnv's directory
 /.direnv
 

API-CHANGELOG.md

@@ -39,6 +39,7 @@ 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
 

flake.lock

@@ -36,28 +36,7 @@
     "root": {
       "inputs": {
         "nixpkgs": "nixpkgs",
-        "nixpkgs-custom-glibc": "nixpkgs-custom-glibc",
-        "rust-overlay": "rust-overlay"
-      }
-    },
-    "rust-overlay": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1784611586,
-        "narHash": "sha256-OfqgY+0hp/zseZB7uyH0U8kIDPS4scZZCyAurEplvG0=",
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "rev": "14f58845249f3552a89b07772626b8d3c632fa86",
-        "type": "github"
-      },
-      "original": {
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "type": "github"
+        "nixpkgs-custom-glibc": "nixpkgs-custom-glibc"
       }
     }
   },

flake.nix

@@ -10,25 +10,12 @@
       url = "github:NixOS/nixpkgs/9cd98386a38891d1074fc18036b842dc4416f562";
       flake = false;
     };
-    # Pinned Rust toolchains, delivered from the Nix store. Lets the Nix CI
-    # image and dev shell honour the single `rust-toolchain.toml` pin (shared
-    # with the rustup-based non-Nix runners) while staying hermetic — the
-    # toolchain lands in the image's Nix closure and is locked by flake.lock.
-    rust-overlay = {
-      url = "github:oxalica/rust-overlay";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
   };
 
   outputs =
-    {
-      nixpkgs,
-      nixpkgs-custom-glibc,
-      rust-overlay,
-      ...
-    }:
+    { nixpkgs, nixpkgs-custom-glibc, ... }:
     let
-      forEachSystem = import ./nix/utils.nix { inherit nixpkgs nixpkgs-custom-glibc rust-overlay; };
+      forEachSystem = import ./nix/utils.nix { inherit nixpkgs nixpkgs-custom-glibc; };
     in
     {
       devShells = forEachSystem (import ./nix/devshell.nix);

nix/docker/Dockerfile

@@ -12,7 +12,6 @@ COPY nix/packages.nix /tmp/build/nix/packages.nix
 COPY nix/utils.nix /tmp/build/nix/utils.nix
 COPY flake.nix /tmp/build/
 COPY flake.lock /tmp/build/
-COPY rust-toolchain.toml /tmp/build/
 WORKDIR /tmp/build
 
 FROM builder-source AS builder

nix/docker/README.md

@@ -47,9 +47,7 @@ work without `ca-certificates` being installed in the base image.
      [`test_files/cpp/sources/`](./test_files/cpp/sources) with both `g++` and
      `clang++`, and sanitizers, and
    - compiles the Rust test programs in
-     [`test_files/rust/sources/`](./test_files/rust/sources) with `rustc`, and
-     builds the [`test_files/rust/proc_macro/`](./test_files/rust/proc_macro)
-     workspace with `cargo` to exercise proc-macro dylib loading.
+     [`test_files/rust/sources/`](./test_files/rust/sources) with `rustc`.
 3. **`tester`** — Start again from a clean `BASE_IMAGE` (no Nix toolchain),
    install only the sanitizer runtime libraries
    ([`install-sanitizer-libs.sh`](./install-sanitizer-libs.sh)), and run the
@@ -78,23 +76,20 @@ toolchain being present at runtime. Two pieces make that work:
   [`loader-path.sh`](./loader-path.sh) reports the expected loader path for the
   current architecture, so we can patch the binaries to use the correct loader.
 
-The build then verifies all of this end to end, and the C++ and Rust programs
-go through the same pipeline: each is compiled in `final`, has its `PT_INTERP`
-patched to the target loader, and is then run in the clean `tester` stage to
-confirm it emits the expected diagnostic on a stock base image. The C++ programs
-are in `test_files/cpp/sources/` (a regular binary plus ASan/TSan/UBSan
-variants); the Rust programs are in `test_files/rust/sources/` (a hello binary
-plus panic and overflow-check variants), plus the `test_files/rust/proc_macro/`
-workspace — a crate whose compilation additionally loads a proc-macro dylib, and
-whose resulting binary is patched and run like the others.
+The build then verifies all of this end to end: the C++ test programs in
+`test_files/cpp/sources/` (a regular binary plus ASan/TSan/UBSan variants) and
+the Rust test programs in `test_files/rust/sources/` (a hello binary plus panic
+and overflow-check variants) are compiled in `final`, their `PT_INTERP` is
+patched to the target loader, and they are run in the clean `tester` stage to
+confirm each emits the expected diagnostic on a stock base image.
 
 ## Files
 
-| File                                                                    | Purpose                                                                              |
-| ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
-| [`./Dockerfile`](./Dockerfile)                                          | Multi-stage build described above.                                                   |
-| [`./loader-path.sh`](./loader-path.sh)                                  | Print the dynamic-linker (`PT_INTERP`) path for the current architecture.            |
-| [`./test_files/cpp/`](./test_files/cpp)                                 | C++ sanitizer smoke test: sources + compile/run scripts.                             |
-| [`./test_files/rust/`](./test_files/rust)                               | Rust smoke test: rustc sources + a cargo proc-macro workspace + compile/run scripts. |
-| [`/bin/check-tools.sh`](../../bin/check-tools.sh)                       | Verify every expected tools are present and runnable.                                |
-| [`/bin/install-sanitizer-libs.sh`](../../bin/install-sanitizer-libs.sh) | Install `libasan`/`libtsan`/`libubsan` runtimes on the supported base images.        |
+| File                                                                    | Purpose                                                                       |
+| ----------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
+| [`./Dockerfile`](./Dockerfile)                                          | Multi-stage build described above.                                            |
+| [`./loader-path.sh`](./loader-path.sh)                                  | Print the dynamic-linker (`PT_INTERP`) path for the current architecture.     |
+| [`./test_files/cpp/`](./test_files/cpp)                                 | C++ sanitizer smoke test: sources + compile/run scripts.                      |
+| [`./test_files/rust/`](./test_files/rust)                               | Rust rustc smoke test: sources + compile/run scripts.                         |
+| [`/bin/check-tools.sh`](../../bin/check-tools.sh)                       | Verify every expected tools are present and runnable.                         |
+| [`/bin/install-sanitizer-libs.sh`](../../bin/install-sanitizer-libs.sh) | Install `libasan`/`libtsan`/`libubsan` runtimes on the supported base images. |

nix/docker/test_files/rust/compile-sources.sh

@@ -40,29 +40,6 @@ compile hello
 compile panic
 compile overflow "-C overflow-checks=on"
 
-function compile_proc_macro() {
-    local proj="${src_dir}/../proc_macro"
-
-    echo "=== Building proc-macro workspace (cargo) ==="
-    cargo build --manifest-path "${proj}/Cargo.toml" --offline
-
-    local built="${proj}/target/debug/test_macro"
-    if [ ! -f "${built}" ]; then
-        echo "ERROR: built test_macro binary not found at ${built}" >&2
-        exit 1
-    fi
-
-    local binary="${dst_dir}/proc_macro"
-    cp "${built}" "${binary}"
-
-    echo "=== Patching ${binary} to use ${loader} as PT_INTERP ==="
-    patchelf --set-interpreter "${loader}" --remove-rpath "${binary}"
-
-    rm -rf "${proj}/target"
-}
-
-compile_proc_macro
-
 echo "=== All binaries compiled ==="
 
 ls -la "${dst_dir}"

nix/docker/test_files/rust/proc_macro/Cargo.lock

@@ -1,14 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 4
-
-[[package]]
-name = "echo_macro"
-version = "0.0.0"
-
-[[package]]
-name = "test_macro"
-version = "0.0.0"
-dependencies = [
- "echo_macro",
-]

nix/docker/test_files/rust/proc_macro/Cargo.toml

@@ -1,3 +0,0 @@
-[workspace]
-resolver = "2"
-members = ["echo_macro", "test_macro"]

nix/docker/test_files/rust/proc_macro/echo_macro/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "echo_macro"
-version = "0.0.0"
-edition = "2024"
-publish = false
-
-[lib]
-proc-macro = true

nix/docker/test_files/rust/proc_macro/echo_macro/src/lib.rs

@@ -1,6 +0,0 @@
-use proc_macro::TokenStream;
-
-#[proc_macro]
-pub fn define_echo(item: TokenStream) -> TokenStream {
-    format!("fn echo() -> u32 {{ {item} }}").parse().unwrap()
-}

nix/docker/test_files/rust/proc_macro/test_macro/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "test_macro"
-version = "0.0.0"
-edition = "2024"
-publish = false
-
-[dependencies]
-echo_macro = { path = "../echo_macro" }

nix/docker/test_files/rust/proc_macro/test_macro/src/main.rs

@@ -1,9 +0,0 @@
-use echo_macro::define_echo;
-
-define_echo!(42);
-
-fn main() {
-    let a = echo();
-    println!("proc-macro answer = {a}");
-    assert_eq!(a, 42, "proc-macro expansion produced the wrong value");
-}

nix/docker/test_files/rust/run-binaries.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 # Run pre-compiled Rust binaries and confirm each emits its expected diagnostic.
 # Binaries must already exist in <bins_dir> as <name> for name in
-# {hello,panic,overflow,proc_macro}.
+# {hello,panic,overflow}.
 
 set -eo pipefail
 
@@ -54,13 +54,12 @@ declare -A expect=(
     [hello]="Hello from main thread"
     [panic]="explicit panic from test"
     [overflow]="attempt to add with overflow"
-    [proc_macro]="proc-macro answer = 42"
 )
 
-for name in hello panic overflow proc_macro; do
+for name in hello panic overflow; do
     binary="${bins_dir}/${name}"
 
-    if [ "${name}" = "hello" ] || [ "${name}" = "proc_macro" ]; then
+    if [ "${name}" = "hello" ]; then
         expected_rc=0
     else
         expected_rc=nonzero

nix/packages.nix

@@ -15,8 +15,6 @@ let
   runClangTidy = pkgs.writeShellScriptBin "run-clang-tidy" ''
     exec ${pkgs.python3}/bin/python3 ${llvmPackages.clang-unwrapped}/bin/run-clang-tidy "$@"
   '';
-
-  rustToolchain = pkgs.rust-bin.fromRustupToolchainFile ../rust-toolchain.toml;
 in
 {
   inherit
@@ -65,10 +63,14 @@ in
     vim
     zip
     # Rust packages
+    cargo
     cargo-audit
     cargo-llvm-cov
     cargo-nextest
+    clippy
     corrosion
-    rustToolchain
+    rust-analyzer
+    rustc
+    rustfmt
   ];
 }

nix/utils.nix

@@ -1,8 +1,4 @@
-{
-  nixpkgs,
-  nixpkgs-custom-glibc,
-  rust-overlay,
-}:
+{ nixpkgs, nixpkgs-custom-glibc }:
 function:
 nixpkgs.lib.genAttrs
   [
@@ -14,12 +10,7 @@ nixpkgs.lib.genAttrs
   (
     system:
     function {
-      # rust-overlay adds `pkgs.rust-bin`, from which we build the pinned Rust
-      # toolchain (see packages.nix). Consumed by both the CI image and dev shell.
-      pkgs = import nixpkgs {
-        inherit system;
-        overlays = [ (import rust-overlay) ];
-      };
+      pkgs = import nixpkgs { inherit system; };
       # glibc 2.31 — matches the system libc on Ubuntu 20.04 LTS. Sourced
       # from the nixpkgs snapshot pinned via the `nixpkgs-custom-glibc`
       # flake input, so the build uses the compiler from that snapshot

rust-toolchain.toml

@@ -1,4 +1,8 @@
+# Rust toolchain pin for rustup-based CI runners and local development.
+# rustup reads this file and installs the pinned toolchain (see the
+# prepare-runner action in XRPLF/actions, which runs `rustup toolchain install`).
+# NOTE: the Nix CI image and development shell ignore this file; its rustc comes from flake.lock.
 [toolchain]
 channel = "1.95"
-components = ["rustfmt", "clippy", "rust-analyzer"]
+components = ["rustfmt", "clippy"]
 profile = "minimal"

src/libxrpl/tx/transactors/lending/LoanPay.cpp

@@ -33,34 +33,6 @@
 
 namespace xrpl {
 
-namespace {
-// Returns the account's true, unclamped balance in `asset`, for use only in
-// fund-conservation checks. accountHolds(..., SpendableHandling::FullBalance)
-// cannot be used for this: for XRP it always defers to xrpLiquid, which
-// subtracts the account's reserve, so a payee sitting below its own reserve
-// would appear to receive nothing even though its raw ledger balance grew.
-// That mismatch is exactly what a conservation check must not see.
-STAmount
-conservationBalance(ReadView const& view, AccountID const& id, Asset const& asset, beast::Journal j)
-{
-    if (isXRP(asset))
-    {
-        auto const sle = view.read(keylet::account(id));
-        if (!sle)
-            return STAmount{};
-        return view.balanceHookIOU(id, xrpAccount(), sle->getFieldAmount(sfBalance));
-    }
-    return accountHolds(
-        view,
-        id,
-        asset,
-        FreezeHandling::IgnoreFreeze,
-        AuthHandling::IgnoreAuth,
-        j,
-        SpendableHandling::FullBalance);
-}
-}  // namespace
-
 bool
 LoanPay::checkExtraFeatures(PreflightContext const& ctx)
 {
@@ -612,13 +584,34 @@ LoanPay::doApply()
     }
 
     // These three values are used to check that funds are conserved after the transfers
-    auto const accountBalanceBefore = conservationBalance(view, accountID_, asset, j_);
+    auto const accountBalanceBefore = accountHolds(
+        view,
+        accountID_,
+        asset,
+        FreezeHandling::IgnoreFreeze,
+        AuthHandling::IgnoreAuth,
+        j_,
+        SpendableHandling::FullBalance);
     auto const vaultBalanceBefore = accountID_ == vaultPseudoAccount
         ? STAmount{asset, 0}
-        : conservationBalance(view, vaultPseudoAccount, asset, j_);
+        : accountHolds(
+              view,
+              vaultPseudoAccount,
+              asset,
+              FreezeHandling::IgnoreFreeze,
+              AuthHandling::IgnoreAuth,
+              j_,
+              SpendableHandling::FullBalance);
     auto const brokerBalanceBefore = accountID_ == brokerPayee
         ? STAmount{asset, 0}
-        : conservationBalance(view, brokerPayee, asset, j_);
+        : accountHolds(
+              view,
+              brokerPayee,
+              asset,
+              FreezeHandling::IgnoreFreeze,
+              AuthHandling::IgnoreAuth,
+              j_,
+              SpendableHandling::FullBalance);
 
     if (totalPaidToVaultRounded != beast::kZero)
     {
@@ -674,13 +667,33 @@ LoanPay::doApply()
 #endif
 
     // Check that funds are conserved
-    auto const accountBalanceAfter = conservationBalance(view, accountID_, asset, j_);
+    auto const accountBalanceAfter = accountHolds(
+        view,
+        accountID_,
+        asset,
+        FreezeHandling::IgnoreFreeze,
+        AuthHandling::IgnoreAuth,
+        j_,
+        SpendableHandling::FullBalance);
     auto const vaultBalanceAfter = accountID_ == vaultPseudoAccount
         ? STAmount{asset, 0}
-        : conservationBalance(view, vaultPseudoAccount, asset, j_);
-    auto const brokerBalanceAfter = accountID_ == brokerPayee
-        ? STAmount{asset, 0}
-        : conservationBalance(view, brokerPayee, asset, j_);
+        : accountHolds(
+              view,
+              vaultPseudoAccount,
+              asset,
+              FreezeHandling::IgnoreFreeze,
+              AuthHandling::IgnoreAuth,
+              j_,
+              SpendableHandling::FullBalance);
+    auto const brokerBalanceAfter = accountID_ == brokerPayee ? STAmount{asset, 0}
+                                                              : accountHolds(
+                                                                    view,
+                                                                    brokerPayee,
+                                                                    asset,
+                                                                    FreezeHandling::IgnoreFreeze,
+                                                                    AuthHandling::IgnoreAuth,
+                                                                    j_,
+                                                                    SpendableHandling::FullBalance);
     auto const balanceScale = [&]() {
         // Find a reasonable scale to use for the balance comparisons.
         //

src/test/app/Loan_test.cpp

@@ -8547,107 +8547,6 @@ protected:
             });
     }
 
-    void
-    testLoanPayFundsConservedPayeeBelowReserve(FeatureBitset features)
-    {
-        // Regression test: LoanPay::doApply's fund-conservation check used to
-        // read XRP balances via accountHolds(..., SpendableHandling::
-        // FullBalance), which for XRP always defers to xrpLiquid (balance
-        // minus reserve, clamped at zero). When the broker fee landed on a
-        // payee sitting below its own reserve, that payee's clamped balance
-        // stayed zero and the fee vanished from the conservation sum,
-        // tripping "funds are conserved (with rounding)".
-        testcase << "LoanPay funds conserved: broker fee payee below reserve";
-
-        using namespace jtx;
-
-        Env env(*this, features);
-
-        Account const issuer{"issuer"};
-        Account const lender{"lender"};
-        Account const borrower{"borrower"};
-
-        // Broker defaults match the fuzz workload: ManagementFeeRate = 100
-        // tenth-bips. The service fee guarantees feePaid > 0 on the first
-        // regular payment.
-        BrokerParameters const brokerParams;
-        Number const serviceFeeValue{2};
-        LoanParameters const loanParams{
-            .account = borrower,
-            .counter = lender,
-            .principalRequest = 1000,
-            .serviceFee = serviceFeeValue,
-            .interest = TenthBips32{percentageToTenthBips(12)},
-            .payTotal = 12,
-            .payInterval = 3600};
-
-        auto const loanOpt =
-            createLoan(env, AssetType::XRP, brokerParams, loanParams, issuer, lender, borrower);
-        if (!BEAST_EXPECT(loanOpt))
-            return;
-        auto const& [broker, loanKeylet, brokerPseudo] = *loanOpt;
-
-        auto const vaultPseudo = [&]() {
-            auto const vaultSle = env.le(keylet::vault(broker.vaultID));
-            BEAST_EXPECT(vaultSle);
-            return vaultSle ? vaultSle->at(sfAccount) : AccountID{};
-        }();
-
-        // Raw AccountRoot balance, matching LoanPay::doApply's conservation
-        // check (not the reserve-clamped accountHolds()/xrpLiquid() value).
-        auto rawBalance = [&](AccountID const& id) -> STAmount {
-            auto const sle = env.le(keylet::account(id));
-            return sle ? sle->getFieldAmount(sfBalance) : STAmount{};
-        };
-        auto lenderReserve = [&] {
-            return env.current()->fees().accountReserve(ownerCount(env, lender), 1);
-        };
-
-        STAmount const baseFee{env.current()->fees().base};
-
-        // Park the lender (broker owner, fee payee) exactly at its reserve,
-        // then burn part of the reserve with an oversized transaction fee.
-        // Fees are exempt from the reserve check, so the balance ends up
-        // below the reserve.
-        env(pay(lender, issuer, rawBalance(lender.id()) - lenderReserve() - baseFee));
-        env(noop(lender), Fee(XRP(100)));
-        env.close();
-        BEAST_EXPECT(env.balance(lender) < lenderReserve());
-
-        // First regular payment, exactly the amount due.
-        auto const state = getCurrentState(env, broker, loanKeylet);
-        STAmount const serviceFee = broker.asset(serviceFeeValue);
-        STAmount const roundedPeriodicPayment{
-            broker.asset,
-            roundPeriodicPayment(broker.asset, state.periodicPayment, state.loanScale)};
-        STAmount const totalDue = roundToScale(
-            roundedPeriodicPayment + serviceFee, state.loanScale, Number::RoundingMode::Upward);
-
-        auto const borrowerBefore = rawBalance(borrower.id());
-        auto const vaultBefore = rawBalance(vaultPseudo);
-        auto const lenderBefore = rawBalance(lender.id());
-
-        // Before the fix, this aborted inside LoanPay::doApply on
-        // XRPL_ASSERT_PARTS(goodRounding, "xrpl::LoanPay::doApply", "funds
-        // are conserved (with rounding)").
-        env(loan::pay(borrower, loanKeylet.key, totalDue));
-        env.close();
-
-        auto const borrowerAfter = rawBalance(borrower.id());
-        auto const vaultAfter = rawBalance(vaultPseudo);
-        auto const lenderAfter = rawBalance(lender.id());
-
-        // The broker fee reached the lender's AccountRoot, even though the
-        // lender's balance remains below its reserve.
-        BEAST_EXPECT(lenderAfter > lenderBefore);
-        BEAST_EXPECT(lenderAfter < lenderReserve());
-
-        // Total funds conserved across the payer, vault, and fee payee.
-        BEAST_EXPECT(
-            borrowerBefore - baseFee + vaultBefore + lenderBefore ==
-            borrowerAfter + vaultAfter + lenderAfter);
-    }
-
     void
     runAmendmentIndependent()
     {
@@ -8681,8 +8580,6 @@ protected:
         testLoanPayLateFullPaymentBypassesPenalties(features);
         testLoanCoverMinimumRoundingExploit(features);
 #endif
-        testLoanPayFundsConservedPayeeBelowReserve(features);
-
         // Lifecycle
         testLifecycle(features);
         testLoanSet(features);

src/test/rpc/Submit_test.cpp

@@ -2,20 +2,104 @@
 #include <test/jtx/Env.h>
 #include <test/jtx/JTx.h>
 #include <test/jtx/amount.h>
+#include <test/jtx/envconfig.h>
 #include <test/jtx/pay.h>
 
+#include <xrpld/core/Config.h>
+
 #include <xrpl/basics/strHex.h>
 #include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/config/Constants.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
 #include <xrpl/protocol/Seed.h>
+#include <xrpl/protocol/Serializer.h>
 #include <xrpl/protocol/jss.h>
 
+#include <memory>
+
 namespace xrpl::test {
 
 class Submit_test : public beast::unit_test::Suite
 {
 public:
+    void
+    testAugmentedFields()
+    {
+        testcase("Augmented fields in sign-and-submit mode");
+
+        using namespace jtx;
+
+        // Enable signing support in config
+        Env env{*this, envconfig([](std::unique_ptr<Config> cfg) {
+                    static std::string const kSigningSupportCfg =
+                        std::string("[") + Sections::kSigningSupport + "]\ntrue";
+                    cfg->loadFromString(kSigningSupportCfg);
+                    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();
+            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
     testFailHardValidation()
     {
@@ -89,6 +173,7 @@ public:
     void
     run() override
     {
+        testAugmentedFields();
         testFailHardValidation();
     }
 };

src/xrpld/rpc/detail/TransactionSign.cpp

@@ -19,6 +19,7 @@
 #include <xrpl/basics/Slice.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/contract.h>
+#include <xrpl/basics/safe_cast.h>
 #include <xrpl/basics/strHex.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/core/NetworkIDService.h>
@@ -804,6 +805,8 @@ 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&)
@@ -817,6 +820,33 @@ 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] =
+            safeCast<json::Value::UInt>(currentLedgerState->accountSeqNext);
+        jvResult[jss::account_sequence_available] =
+            safeCast<json::Value::UInt>(currentLedgerState->accountSeqAvail);
+        jvResult[jss::open_ledger_cost] = to_string(currentLedgerState->minFeeRequired);
+        jvResult[jss::validated_ledger_index] =
+            safeCast<json::Value::UInt>(currentLedgerState->validatedLedger);
+    }
+}
+
+//------------------------------------------------------------------------------
+
 [[nodiscard]] static XRPAmount
 getTxFee(Application const& app, Config const& config, json::Value tx)
 {

src/xrpld/rpc/detail/TransactionSign.h

@@ -22,6 +22,20 @@ 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/transaction/Submit.cpp

@@ -6,7 +6,6 @@
 
 #include <xrpl/basics/Slice.h>
 #include <xrpl/basics/StringUtilities.h>
-#include <xrpl/basics/safe_cast.h>
 #include <xrpl/basics/strHex.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/ErrorCodes.h>
@@ -14,7 +13,6 @@
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/Serializer.h>
 #include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/XRPAmount.h>
 #include <xrpl/protocol/jss.h>
 #include <xrpl/resource/Fees.h>
 #include <xrpl/tx/apply.h>
@@ -155,24 +153,7 @@ doSubmit(RPC::JsonContext& context)
             jvResult[jss::engine_result_code] = transaction->getResult();
             jvResult[jss::engine_result_message] = sHuman;
 
-            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] =
-                    safeCast<json::Value::UInt>(currentLedgerState->accountSeqNext);
-                jvResult[jss::account_sequence_available] =
-                    safeCast<json::Value::UInt>(currentLedgerState->accountSeqAvail);
-                jvResult[jss::open_ledger_cost] = to_string(currentLedgerState->minFeeRequired);
-                jvResult[jss::validated_ledger_index] =
-                    safeCast<json::Value::UInt>(currentLedgerState->validatedLedger);
-            }
+            RPC::populateAugmentedSubmitFields(jvResult, transaction);
         }
 
         return jvResult;