realonbebeto
diff --git a/‎.github/workflows/integration_test.yml‎
Lines changed: 40 additions & 2 deletions b/‎.github/workflows/integration_test.yml‎
Lines changed: 40 additions & 2 deletions
diff --git a/‎CHANGELOG.md‎
Lines changed: 4 additions & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 4 additions & 0 deletions
diff --git a/‎CONTRIBUTING.md‎
Lines changed: 66 additions & 12 deletions b/‎CONTRIBUTING.md‎
Lines changed: 66 additions & 12 deletions
diff --git a/‎codecov.yml‎
Lines changed: 15 additions & 0 deletions b/‎codecov.yml‎
Lines changed: 15 additions & 0 deletions
diff --git a/‎src/asynch/ledger/mod.rs‎
Lines changed: 4 additions & 21 deletions b/‎src/asynch/ledger/mod.rs‎
Lines changed: 4 additions & 21 deletions
diff --git a/‎src/models/results/mod.rs‎
Lines changed: 80 additions & 10 deletions b/‎src/models/results/mod.rs‎
Lines changed: 80 additions & 10 deletions
diff --git a/‎tests/cli_integration.rs‎
Lines changed: 7 additions & 2 deletions b/‎tests/cli_integration.rs‎
Lines changed: 7 additions & 2 deletions
diff --git a/‎tests/common/constants.rs‎
Lines changed: 3 additions & 0 deletions b/‎tests/common/constants.rs‎
Lines changed: 3 additions & 0 deletions
@@ -13,6 +13,10 @@ env:
   # rippled binary was renamed to xrpld; use the new image name.
   # Tracks xrpl.js PR #3270 (https://github.com/XRPLF/xrpl.js/pull/3270).
   XRPLD_DOCKER_IMAGE: rippleci/xrpld:develop
+  # Files measured by the integration coverage gate are the inverse of this regex.
+  # Unit-test territory (models, core, utils, _serde) is excluded; integration territory
+  # (CLI, asynch::clients, account/, ledger/, transaction/, faucet) is what remains.
+  COVERAGE_IGNORE_REGEX: '(_serde|core|models|utils)/|constants\.rs$|macros\.rs$|lib\.rs$|wallet/(mod|exceptions)\.rs$|tests/'
 
 jobs:
   integration_test:
@@ -36,6 +40,11 @@ jobs:
 
       - uses: dtolnay/rust-toolchain@stable
 
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@65851e10cd6c377f11a60e600abc07cb08643468 # v2.79.3
+        with:
+          tool: cargo-llvm-cov
+
       - name: Cache cargo registry
         uses: actions/cache@v4
         with:
@@ -47,11 +56,40 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-cargo-integration-
 
-      - name: Run integration tests
-        run: cargo test --release --features std,json-rpc,helpers,integration --test integration_test -- --test-threads=1
+      - name: Run integration tests under coverage
+        run: |
+          cargo llvm-cov --no-report --release \
+            --features std,json-rpc,helpers,cli,websocket,integration \
+            --test integration_test \
+            --test cli_integration \
+            --test funding \
+            --test utils \
+            --test test_utils \
+            -- --test-threads=1
         env:
           RUST_BACKTRACE: 1
 
+      - name: Generate lcov report (scoped to integration territory)
+        run: |
+          cargo llvm-cov report --release \
+            --lcov --output-path lcov.info \
+            --ignore-filename-regex '${{ env.COVERAGE_IGNORE_REGEX }}'
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@75cd11691c0faa626561e295848008c8a7dddffe # v5.5.4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: lcov.info
+          flags: integration
+          fail_ci_if_error: true
+
+      - name: Upload coverage report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-lcov-report
+          path: lcov.info
+
       - name: Dump xrpld logs and stop container
         if: always()
         run: |
 
@@ -17,16 +17,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - New `xrpl::signing` module containing the pure-crypto signing helpers (`sign`, `multisign`, `prepare_transaction`) extracted from `asynch::transaction` and `transaction`. Available with just `core + models + wallet` features (no `helpers`/runtime/client dependency). The legacy paths `asynch::transaction::sign` and `transaction::multisign` are preserved as re-exports for backward compatibility.
 - Expanded unit-test coverage and raised CI thresholds: lines `73 → 83`, regions `75 → 85`, functions `67 → 73`.
 - Codecov integration with per-PR project (≥83%) and patch (≥80% on new/modified lines) gates.
+- Integration-test coverage gate: a CI workflow runs all five integration test binaries under `cargo-llvm-cov`, uploads to codecov under an `integration` flag, and gates the project at ≥65%.
 
 ### Changed
 
 - Unit-test and integration-test coverage are now scoped via Cargo feature flags rather than path regex. The unit-test workflow builds with `--no-default-features --features std,core,utils,wallet,models`, so integration-territory code (CLI, async clients, sync wrappers, faucet) simply isn't compiled and doesn't appear in the unit coverage report.
 - Network-dependent inline tests in `src/asynch/transaction/` and `src/asynch/wallet/` (`test_autofill_txn`, `test_autofill_and_sign`, `test_submit_and_wait`, `test_generate_faucet_wallet`) are now gated behind `feature = "integration"` so `cargo test --release` is hermetic by default.
+- Codecov **patch** coverage is now gated per flag (separate `unit` and `integration` sections) rather than a single combined gate.
 
 ### Fixed
 
 - `RipplePathFind::destination_amount` changed from `Currency<'a>` to `Amount<'a>` to match the XRPL wire format.
 - `NoRippleCheckRole` no longer serializes with the `#[serde(tag = "role")]` discriminator; now emits a plain `snake_case` string matching the XRPL wire format.
+- `is_success()` now reports success correctly for responses deserialized into typed `XRPLResult` variants (e.g. `ServerInfo`); it consults the preserved raw result JSON instead of the re-serialized typed value.
+- `get_latest_open_ledger_sequence` now uses the `ledger_current` request; it previously sent `ledger { ledger_index: "open" }`, which rippled rejects with `invalidParams`.
 
 ## [[v1.1.0]]
 
 
@@ -76,15 +76,24 @@ From the `xrpl-rust` folder, run the following commands:
 docker run -p 5005:5005 -p 6006:6006 --rm -it --name xrpld_standalone \
   --volume "$PWD/.ci-config/:/etc/xrpld/" \
   rippleci/xrpld:develop --standalone
-cargo test --release --features integration,std,json-rpc,helpers
+cargo test --release \
+  --features std,json-rpc,helpers,cli,websocket,integration \
+  -- --test-threads=1
 ```
 
 To run a specific group of tests (e.g. escrow):
 
 ```bash
-cargo test --release --features integration,std,json-rpc,helpers escrow
+cargo test --release \
+  --features std,json-rpc,helpers,cli,websocket,integration \
+  escrow -- --test-threads=1
 ```
 
+The feature set matches `.github/workflows/integration_test.yml`; `cli` and
+`websocket` are required for `cli_integration.rs` and the websocket tests in
+`utils.rs` to compile. `--test-threads=1` matches CI and prevents concurrent
+tests from racing on the shared `xrpld` container.
+
 Breaking down the `docker run` command:
 
 - `-p 5005:5005 -p 6006:6006` exposes the HTTP JSON-RPC and WebSocket admin ports.
@@ -102,24 +111,69 @@ Breaking down the `docker run` command:
 
 ### Coverage
 
-Coverage is measured with [`cargo-llvm-cov`](https://github.com/taiki-e/cargo-llvm-cov).
+Coverage is measured with [`cargo-llvm-cov`](https://github.com/taiki-e/cargo-llvm-cov)
+and uploaded to codecov under two separate flags:
+
+- **unit** — pure-logic code (models, core, utils, `_serde`, signing). Built
+  with a minimal feature set so network-bound modules are not compiled.
+- **integration** — network-bound code (CLI, async clients, faucet, helpers
+  under `account/`, `ledger/`, `transaction/`). Scoped via
+  `--ignore-filename-regex` so unit-territory files do not dilute the
+  integration metric.
 
-Install the tool and run a coverage report locally:
+Install the tool once:
 
 ```bash
 cargo install cargo-llvm-cov --locked
-cargo llvm-cov --summary-only
 ```
 
-The CI enforces the following minimum thresholds (current baseline is ~78% lines / ~68% regions / ~75% functions, measured with default features only — integration tests are excluded from coverage):
+#### Unit coverage
+
+Matches `.github/workflows/unit_test.yml`:
+
+```bash
+cargo llvm-cov \
+  --no-default-features --features std,core,utils,wallet,models \
+  --summary-only \
+  --fail-under-lines 83 \
+  --fail-under-regions 85 \
+  --fail-under-functions 73
+```
+
+The `--fail-under-*` flags mirror the thresholds CI enforces:
+
+| Metric    | Threshold |
+| --------- | --------- |
+| Lines     | 83%       |
+| Regions   | 85%       |
+| Functions | 73%       |
+
+#### Integration coverage
+
+Requires the standalone `xrpld` container running (see [Integration Tests](#integration-tests)).
+Matches `.github/workflows/integration_test.yml`:
+
+```bash
+# Collect coverage from the integration suite (writes raw profile data)
+cargo llvm-cov --no-report --release \
+  --features std,json-rpc,helpers,cli,websocket,integration \
+  --test integration_test --test cli_integration --test funding \
+  --test utils --test test_utils \
+  -- --test-threads=1
+
+# Generate lcov scoped to integration territory
+cargo llvm-cov report --release --lcov --output-path lcov.info \
+  --ignore-filename-regex '(_serde|core|models|utils)/|constants\.rs$|macros\.rs$|lib\.rs$|wallet/(mod|exceptions)\.rs$|tests/'
+```
+
+The codecov integration target is 65%. The `--ignore-filename-regex` value
+mirrors `COVERAGE_IGNORE_REGEX` in the workflow; without it the integration
+metric would be dominated by unit-territory files the integration suite is
+not designed to exercise.
 
-| Metric    | Minimum |
-| --------- | ------- |
-| Lines     | 75%     |
-| Regions   | 65%     |
-| Functions | 72%     |
+#### HTML report
 
-To generate an HTML report and open it in a browser:
+For local exploration:
 
 ```bash
 cargo llvm-cov --open
 
@@ -6,10 +6,22 @@ coverage:
         threshold: 1%
         flags:
           - unit
+      integration:
+        target: 65%
+        threshold: 1%
+        flags:
+          - integration
     patch:
       default:
         target: 80%
         threshold: 1%
+        flags:
+          - unit
+      integration:
+        target: 80%
+        threshold: 1%
+        flags:
+          - integration
 
 comment:
   layout: "reach, diff, flags, files"
@@ -19,3 +31,6 @@ flags:
   unit:
     paths:
       - src/
+  integration:
+    paths:
+      - src/
@@ -3,7 +3,7 @@ use core::{cmp::min, convert::TryInto};
 use alloc::string::ToString;
 
 use crate::models::{
-    requests::{fee::Fee, ledger::Ledger},
+    requests::{fee::Fee, ledger::Ledger, ledger_current::LedgerCurrent},
     results::{self},
     XRPAmount,
 };
@@ -38,26 +38,9 @@ pub async fn get_latest_validated_ledger_sequence(
 pub async fn get_latest_open_ledger_sequence(
     client: &impl XRPLAsyncClient,
 ) -> XRPLHelperResult<u32> {
-    let ledger_response = client
-        .request(
-            Ledger::new(
-                None,
-                None,
-                None,
-                None,
-                None,
-                None,
-                Some("open".into()),
-                None,
-                None,
-                None,
-            )
-            .into(),
-        )
-        .await?;
-    let ledger_result: results::ledger::Ledger = ledger_response.try_into()?;
-
-    Ok(ledger_result.ledger_index)
+    let response = client.request(LedgerCurrent::new(None).into()).await?;
+    let result: results::ledger_current::LedgerCurrent = response.try_into()?;
+    Ok(result.ledger_current_index)
 }
 
 pub enum FeeType {
 
@@ -886,18 +886,26 @@ impl<'a> TryInto<XRPLResult<'a>> for XRPLResponse<'a> {
 impl<'a> XRPLResponse<'a> {
     pub fn is_success(&self) -> bool {
         if let Some(status) = &self.status {
-            status == &ResponseStatus::Success
-        } else if let Some(result) = &self.result {
-            match serde_json::to_value(result) {
-                Ok(value) => match value.get("status") {
-                    Some(Value::String(status)) => status == "success",
-                    _ => false,
-                },
-                _ => false,
+            return status == &ResponseStatus::Success;
+        }
+        // Typed `XRPLResult` variants (e.g. `ServerInfo`, `Ping`) drop
+        // unknown fields like `status` during deserialization. `raw_result`
+        // preserves the original JSON, so prefer it; fall back to
+        // re-serializing `result` only for responses constructed without a
+        // raw payload (mostly tests).
+        if let Some(raw) = &self.raw_result {
+            if let Some(Value::String(status)) = raw.get("status") {
+                return status == "success";
             }
-        } else {
-            false
         }
+        if let Some(result) = &self.result {
+            if let Ok(value) = serde_json::to_value(result) {
+                if let Some(Value::String(status)) = value.get("status") {
+                    return status == "success";
+                }
+            }
+        }
+        false
     }
 }
 
@@ -1207,4 +1215,66 @@ mod tests {
         };
         assert!(!response.is_success());
     }
+
+    #[test]
+    fn test_is_success_uses_raw_result_branch() {
+        // raw_result with `status: "success"` returns true even when `status`
+        // and `result` are absent — this is the path typed XRPLResult
+        // variants (e.g. ServerInfo) rely on, since they drop unknown fields
+        // like `status` during deserialization.
+        let response = XRPLResponse {
+            id: None,
+            error: None,
+            error_code: None,
+            error_message: None,
+            forwarded: None,
+            request: None,
+            result: None,
+            raw_result: Some(json!({"status": "success", "info": "x"})),
+            status: None,
+            r#type: None,
+            warning: None,
+            warnings: None,
+        };
+        assert!(response.is_success());
+
+        // raw_result without a `status` field falls through to false.
+        let response = XRPLResponse {
+            id: None,
+            error: None,
+            error_code: None,
+            error_message: None,
+            forwarded: None,
+            request: None,
+            result: None,
+            raw_result: Some(json!({"info": "no status"})),
+            status: None,
+            r#type: None,
+            warning: None,
+            warnings: None,
+        };
+        assert!(!response.is_success());
+    }
+
+    #[test]
+    fn test_is_success_falls_through_when_typed_result_lacks_status() {
+        // A typed result variant serializes without a `status` field, so the
+        // inner pattern in the `result` fallback branch never matches and
+        // control falls through to `false`.
+        let response = XRPLResponse {
+            id: None,
+            error: None,
+            error_code: None,
+            error_message: None,
+            forwarded: None,
+            request: None,
+            result: Some(XRPLResult::Fee(fee_result())),
+            raw_result: None,
+            status: None,
+            r#type: None,
+            warning: None,
+            warnings: None,
+        };
+        assert!(!response.is_success());
+    }
 }
@@ -4,6 +4,9 @@
 //! Genesis account is used for testing since it has unlimited XRP in standalone mode.
 //! Faucet tests use the public testnet since Docker standalone doesn't have a faucet.
 
+#[cfg(all(feature = "integration", feature = "std", feature = "cli"))]
+mod common;
+
 #[cfg(all(feature = "integration", feature = "std", feature = "cli"))]
 mod cli_tests {
     use std::io::{self};
@@ -12,8 +15,10 @@ mod cli_tests {
 
     /// Test-specific constants
     mod constants {
-        // Docker standalone JSON-RPC endpoint
-        pub const TEST_URL: &str = "http://localhost:5005";
+        // Docker standalone JSON-RPC endpoint — canonical definition lives in
+        // tests/common/constants.rs; re-exported here so existing TEST_URL
+        // references keep working.
+        pub use crate::common::constants::STANDALONE_URL as TEST_URL;
 
         // Public testnet for faucet tests only
         pub const TESTNET_URL: &str = "https://s.altnet.rippletest.net:51234";
 
@@ -8,3 +8,6 @@ pub const XRPL_WSS_TEST_NET: &'static str = "wss://testnet.xrpl-labs.com/";
 pub const XRPL_WS_TEST_NET: &'static str = "wss://s.altnet.rippletest.net:51233/";
 
 pub const GENESIS_ACCOUNT: &str = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
+
+/// HTTP JSON-RPC endpoint for local Docker standalone rippled.
+pub const STANDALONE_URL: &str = "http://localhost:5005";