test: Check error consistently in rpc handlers (#8604)

Co-authored-by: Ayaz Salikhov <[email protected]>

src/test/app/AccountDelete_test.cpp

@@ -32,6 +32,7 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
 #include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
@@ -894,8 +895,9 @@ public:
                 auto const jNoCred = credentials::ledgerEntry(env, becky, carol, credType);
                 BEAST_EXPECT(
                     jNoCred.isObject() && jNoCred.isMember(jss::result) &&
-                    jNoCred[jss::result].isMember(jss::error) &&
-                    jNoCred[jss::result][jss::error] == "entryNotFound");
+                    jNoCred[jss::result][jss::error] == "entryNotFound" &&
+                    jNoCred[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jNoCred[jss::result][jss::error_message] == "Entry not found.");
             }
 
             testcase("Credentials that aren't required");
@@ -918,8 +920,9 @@ public:
 
                 BEAST_EXPECT(
                     jNoCred.isObject() && jNoCred.isMember(jss::result) &&
-                    jNoCred[jss::result].isMember(jss::error) &&
-                    jNoCred[jss::result][jss::error] == "entryNotFound");
+                    jNoCred[jss::result][jss::error] == "entryNotFound" &&
+                    jNoCred[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jNoCred[jss::result][jss::error_message] == "Entry not found.");
             }
 
             {
@@ -957,8 +960,9 @@ public:
 
                 BEAST_EXPECT(
                     jNoCred.isObject() && jNoCred.isMember(jss::result) &&
-                    jNoCred[jss::result].isMember(jss::error) &&
-                    jNoCred[jss::result][jss::error] == "entryNotFound");
+                    jNoCred[jss::result][jss::error] == "entryNotFound" &&
+                    jNoCred[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jNoCred[jss::result][jss::error_message] == "Entry not found.");
             }
 
             testcase("Expired credentials");
@@ -994,8 +998,9 @@ public:
                     auto jv = credentials::ledgerEntry(env, john, carol, credType);
                     BEAST_EXPECT(
                         jv.isObject() && jv.isMember(jss::result) &&
-                        jv[jss::result].isMember(jss::error) &&
-                        jv[jss::result][jss::error] == "entryNotFound");
+                        jv[jss::result][jss::error] == "entryNotFound" &&
+                        jv[jss::result][jss::error_code] == RpcEntryNotFound &&
+                        jv[jss::result][jss::error_message] == "Entry not found.");
                 }
             }
         }
@@ -1079,8 +1084,9 @@ public:
                 auto const jv = credentials::ledgerEntry(env, becky, carol, credType);
                 BEAST_EXPECT(
                     jv.isObject() && jv.isMember(jss::result) &&
-                    jv[jss::result].isMember(jss::error) &&
-                    jv[jss::result][jss::error] == "entryNotFound");
+                    jv[jss::result][jss::error] == "entryNotFound" &&
+                    jv[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jv[jss::result][jss::error_message] == "Entry not found.");
             }
         }
 
@@ -1121,8 +1127,9 @@ public:
                 auto const jv = credentials::ledgerEntry(env, becky, carol, credType);
                 BEAST_EXPECT(
                     jv.isObject() && jv.isMember(jss::result) &&
-                    jv[jss::result].isMember(jss::error) &&
-                    jv[jss::result][jss::error] == "entryNotFound");
+                    jv[jss::result][jss::error] == "entryNotFound" &&
+                    jv[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jv[jss::result][jss::error_message] == "Entry not found.");
             }
         }
     }

src/test/app/Batch_test.cpp

@@ -43,6 +43,7 @@
 #include <xrpl/ledger/OpenView.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Batch.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
@@ -2800,6 +2801,7 @@ class Batch_test : public beast::unit_test::Suite
             auto const jrr = env.rpc("submit", strHex(slice))[jss::result];
             expect(
                 jrr[jss::status] == "error" && jrr[jss::error] == "invalidTransaction" &&
+                    !jrr.isMember(jss::error_code) && jrr[jss::error_message].isNull() &&
                     jrr[jss::error_exception] ==
                         "fails local checks: Batch inner transactions are never "
                         "considered validly signed.",
@@ -5407,7 +5409,10 @@ class Batch_test : public beast::unit_test::Suite
 
             // The delegated payment never applied.
             BEAST_EXPECT(env.balance(mallory) == preMallory);
-            BEAST_EXPECT(env.rpc("tx", txIDs[1])[jss::result][jss::error] == "txnNotFound");
+            auto const txResult = env.rpc("tx", txIDs[1])[jss::result];
+            BEAST_EXPECT(txResult[jss::error] == "txnNotFound");
+            BEAST_EXPECT(txResult[jss::error_code] == RpcTxnNotFound);
+            BEAST_EXPECT(txResult[jss::error_message] == "Transaction not found.");
         }
     }
 
@@ -5818,7 +5823,10 @@ class Batch_test : public beast::unit_test::Suite
             validateClosedLedger(env, testCases);
 
             // verify jv2 is not present in the closed ledger.
-            BEAST_EXPECT(env.rpc("tx", txIDs[1])[jss::result][jss::error] == "txnNotFound");
+            auto const txResult = env.rpc("tx", txIDs[1])[jss::result];
+            BEAST_EXPECT(txResult[jss::error] == "txnNotFound");
+            BEAST_EXPECT(txResult[jss::error_code] == RpcTxnNotFound);
+            BEAST_EXPECT(txResult[jss::error_message] == "Transaction not found.");
         }
     }
 

src/test/app/ConfidentialTransferExtended_test.cpp

@@ -20,6 +20,7 @@
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/ConfidentialTransfer.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Protocol.h>
@@ -259,8 +260,9 @@ class ConfidentialTransferExtended_test : public ConfidentialTransferTestBase
 
         auto const credentialDeleted = [&](Env& env, Account const& subject) -> bool {
             auto const credentials = credentials::ledgerEntry(env, subject, dpIssuer, credType);
-            return credentials[jss::result].isMember(jss::error) &&
-                credentials[jss::result][jss::error] == "entryNotFound";
+            return credentials[jss::result][jss::error] == "entryNotFound" &&
+                credentials[jss::result][jss::error_code] == RpcEntryNotFound &&
+                credentials[jss::result][jss::error_message] == "Entry not found.";
         };
 
         // TEST 4: Expired credential with matching depositPreauth entry.

src/test/app/ConfidentialTransfer_test.cpp

@@ -7944,6 +7944,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
             // Signature verification fails — rejected before ZKP check
             auto const jr = env.rpc("submit", strHex(tampered.slice()));
             BEAST_EXPECT(jr[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!jr[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(jr[jss::result][jss::error_message].isNull());
         }
 
         // Variant B: Re-signed with inflated ciphertext.
@@ -8051,6 +8053,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
 
             auto const jr = env.rpc("submit", strHex(tampered.slice()));
             BEAST_EXPECT(jr[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!jr[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(jr[jss::result][jss::error_message].isNull());
         }
 
         // Variant B: Re-signed with all negated ciphertexts.
@@ -8154,6 +8158,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
 
             auto const jr = env.rpc("submit", strHex(tampered.slice()));
             BEAST_EXPECT(jr[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!jr[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(jr[jss::result][jss::error_message].isNull());
         }
 
         // Variant B: Re-signed with combined ciphertext.
@@ -8278,6 +8284,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
             // Signature verification fails
             auto const jr = env.rpc("submit", strHex(tampered.slice()));
             BEAST_EXPECT(jr[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!jr[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(jr[jss::result][jss::error_message].isNull());
         }
 
         // Variant B: Re-signed C1 substitution.
@@ -8368,6 +8376,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
             // signed — transaction rejected before ZKP verification.
             auto const jr = env.rpc("submit", strHex(tampered.slice()));
             BEAST_EXPECT(jr[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!jr[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(jr[jss::result][jss::error_message].isNull());
         }
 
         // -----------------------------------------------------------------

src/test/app/Credentials_test.cpp

@@ -23,6 +23,7 @@
 #include <xrpl/ledger/ApplyViewImpl.h>
 #include <xrpl/ledger/helpers/CredentialHelpers.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
@@ -124,8 +125,9 @@ struct Credentials_test : public beast::unit_test::Suite
                 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
                 BEAST_EXPECT(
                     jle.isObject() && jle.isMember(jss::result) &&
-                    jle[jss::result].isMember(jss::error) &&
-                    jle[jss::result][jss::error] == "entryNotFound");
+                    jle[jss::result][jss::error] == "entryNotFound" &&
+                    jle[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jle[jss::result][jss::error_message] == "Entry not found.");
             }
         }
 
@@ -173,8 +175,9 @@ struct Credentials_test : public beast::unit_test::Suite
                 auto const jle = credentials::ledgerEntry(env, issuer, issuer, credType);
                 BEAST_EXPECT(
                     jle.isObject() && jle.isMember(jss::result) &&
-                    jle[jss::result].isMember(jss::error) &&
-                    jle[jss::result][jss::error] == "entryNotFound");
+                    jle[jss::result][jss::error] == "entryNotFound" &&
+                    jle[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jle[jss::result][jss::error_message] == "Entry not found.");
             }
         }
     }
@@ -222,8 +225,9 @@ struct Credentials_test : public beast::unit_test::Suite
                 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
                 BEAST_EXPECT(
                     jle.isObject() && jle.isMember(jss::result) &&
-                    jle[jss::result].isMember(jss::error) &&
-                    jle[jss::result][jss::error] == "entryNotFound");
+                    jle[jss::result][jss::error] == "entryNotFound" &&
+                    jle[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jle[jss::result][jss::error_message] == "Entry not found.");
             }
 
             // resurrection
@@ -259,8 +263,9 @@ struct Credentials_test : public beast::unit_test::Suite
                 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
                 BEAST_EXPECT(
                     jle.isObject() && jle.isMember(jss::result) &&
-                    jle[jss::result].isMember(jss::error) &&
-                    jle[jss::result][jss::error] == "entryNotFound");
+                    jle[jss::result][jss::error] == "entryNotFound" &&
+                    jle[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jle[jss::result][jss::error_message] == "Entry not found.");
             }
 
             // resurrection
@@ -294,8 +299,9 @@ struct Credentials_test : public beast::unit_test::Suite
                 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
                 BEAST_EXPECT(
                     jle.isObject() && jle.isMember(jss::result) &&
-                    jle[jss::result].isMember(jss::error) &&
-                    jle[jss::result][jss::error] == "entryNotFound");
+                    jle[jss::result][jss::error] == "entryNotFound" &&
+                    jle[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jle[jss::result][jss::error_message] == "Entry not found.");
             }
 
             // resurrection
@@ -331,8 +337,9 @@ struct Credentials_test : public beast::unit_test::Suite
                 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
                 BEAST_EXPECT(
                     jle.isObject() && jle.isMember(jss::result) &&
-                    jle[jss::result].isMember(jss::error) &&
-                    jle[jss::result][jss::error] == "entryNotFound");
+                    jle[jss::result][jss::error] == "entryNotFound" &&
+                    jle[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jle[jss::result][jss::error_message] == "Entry not found.");
             }
 
             // resurrection
@@ -368,8 +375,9 @@ struct Credentials_test : public beast::unit_test::Suite
                 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
                 BEAST_EXPECT(
                     jle.isObject() && jle.isMember(jss::result) &&
-                    jle[jss::result].isMember(jss::error) &&
-                    jle[jss::result][jss::error] == "entryNotFound");
+                    jle[jss::result][jss::error] == "entryNotFound" &&
+                    jle[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jle[jss::result][jss::error_message] == "Entry not found.");
             }
         }
 
@@ -390,8 +398,9 @@ struct Credentials_test : public beast::unit_test::Suite
                 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
                 BEAST_EXPECT(
                     jle.isObject() && jle.isMember(jss::result) &&
-                    jle[jss::result].isMember(jss::error) &&
-                    jle[jss::result][jss::error] == "entryNotFound");
+                    jle[jss::result][jss::error] == "entryNotFound" &&
+                    jle[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jle[jss::result][jss::error_message] == "Entry not found.");
             }
         }
 
@@ -410,8 +419,9 @@ struct Credentials_test : public beast::unit_test::Suite
                 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
                 BEAST_EXPECT(
                     jle.isObject() && jle.isMember(jss::result) &&
-                    jle[jss::result].isMember(jss::error) &&
-                    jle[jss::result][jss::error] == "entryNotFound");
+                    jle[jss::result][jss::error] == "entryNotFound" &&
+                    jle[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jle[jss::result][jss::error_message] == "Entry not found.");
             }
         }
     }
@@ -744,8 +754,9 @@ struct Credentials_test : public beast::unit_test::Suite
                 auto const jDelCred = credentials::ledgerEntry(env, subject, issuer, credType2);
                 BEAST_EXPECT(
                     jDelCred.isObject() && jDelCred.isMember(jss::result) &&
-                    jDelCred[jss::result].isMember(jss::error) &&
-                    jDelCred[jss::result][jss::error] == "entryNotFound");
+                    jDelCred[jss::result][jss::error] == "entryNotFound" &&
+                    jDelCred[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jDelCred[jss::result][jss::error_message] == "Entry not found.");
 
                 BEAST_EXPECT(ownerCount(env, issuer) == 0);
                 BEAST_EXPECT(ownerCount(env, subject) == 1);
@@ -781,8 +792,9 @@ struct Credentials_test : public beast::unit_test::Suite
                 auto const jDelCred = credentials::ledgerEntry(env, subject, issuer, credType);
                 BEAST_EXPECT(
                     jDelCred.isObject() && jDelCred.isMember(jss::result) &&
-                    jDelCred[jss::result].isMember(jss::error) &&
-                    jDelCred[jss::result][jss::error] == "entryNotFound");
+                    jDelCred[jss::result][jss::error] == "entryNotFound" &&
+                    jDelCred[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jDelCred[jss::result][jss::error_message] == "Entry not found.");
             }
         }
     }

src/test/app/Delegate_test.cpp

@@ -38,6 +38,7 @@
 #include <xrpl/json/to_string.h>
 #include <xrpl/ledger/Dir.h>
 #include <xrpl/ledger/helpers/DelegateHelpers.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
@@ -159,6 +160,8 @@ class Delegate_test : public beast::unit_test::Suite
         env.close();
         auto const jle = delegate::entry(env, gw, alice);
         BEAST_EXPECT(jle[jss::result][jss::error] == "entryNotFound");
+        BEAST_EXPECT(jle[jss::result][jss::error_code] == RpcEntryNotFound);
+        BEAST_EXPECT(jle[jss::result][jss::error_message] == "Entry not found.");
 
         // alice can delegate permissions to gw as well
         env(delegate::set(alice, gw, permissions));
@@ -167,6 +170,8 @@ class Delegate_test : public beast::unit_test::Suite
         auto const response = delegate::entry(env, gw, alice);
         // alice has not been granted any permissions by gw
         BEAST_EXPECT(response[jss::result][jss::error] == "entryNotFound");
+        BEAST_EXPECT(response[jss::result][jss::error_code] == RpcEntryNotFound);
+        BEAST_EXPECT(response[jss::result][jss::error_message] == "Entry not found.");
     }
 
     void
@@ -2780,9 +2785,11 @@ class Delegate_test : public beast::unit_test::Suite
             jv[jss::secret] = bob.name();
             auto jrr = env.rpc("json", "sign_for", to_string(jv))[jss::result];
             BEAST_EXPECT(jrr[jss::status] == "error");
+            BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
-                jrr[jss::error_message].asString().contains(
-                    "A Signer may not be the transaction's Account"));
+                jrr[jss::error_message] ==
+                "A Signer may not be the transaction's Account (" + bob.human() + ").");
         }
     }
 

src/test/app/DepositAuth_test.cpp

@@ -28,6 +28,7 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/LedgerFormats.h>
@@ -1143,8 +1144,9 @@ struct DepositPreauth_test : public beast::unit_test::Suite
                     ledgerEntryDepositPreauth(env, bob, {{.issuer = issuer, .credType = credType}});
                 BEAST_EXPECT(
                     jDP.isObject() && jDP.isMember(jss::result) &&
-                    jDP[jss::result].isMember(jss::error) &&
-                    jDP[jss::result][jss::error] == "entryNotFound");
+                    jDP[jss::result][jss::error] == "entryNotFound" &&
+                    jDP[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jDP[jss::result][jss::error_message] == "Entry not found.");
             }
         }
     }
@@ -1232,8 +1234,9 @@ struct DepositPreauth_test : public beast::unit_test::Suite
                     auto const jDelCred = credentials::ledgerEntry(env, alice, issuer, credType);
                     BEAST_EXPECT(
                         jDelCred.isObject() && jDelCred.isMember(jss::result) &&
-                        jDelCred[jss::result].isMember(jss::error) &&
-                        jDelCred[jss::result][jss::error] == "entryNotFound");
+                        jDelCred[jss::result][jss::error] == "entryNotFound" &&
+                        jDelCred[jss::result][jss::error_code] == RpcEntryNotFound &&
+                        jDelCred[jss::result][jss::error_message] == "Entry not found.");
                 }
 
                 {
@@ -1283,8 +1286,9 @@ struct DepositPreauth_test : public beast::unit_test::Suite
                 auto const jDelCred = credentials::ledgerEntry(env, gw, issuer, credType);
                 BEAST_EXPECT(
                     jDelCred.isObject() && jDelCred.isMember(jss::result) &&
-                    jDelCred[jss::result].isMember(jss::error) &&
-                    jDelCred[jss::result][jss::error] == "entryNotFound");
+                    jDelCred[jss::result][jss::error] == "entryNotFound" &&
+                    jDelCred[jss::result][jss::error_code] == RpcEntryNotFound &&
+                    jDelCred[jss::result][jss::error_message] == "Entry not found.");
 
                 BEAST_EXPECT(ownerCount(env, issuer) == 0);
                 BEAST_EXPECT(ownerCount(env, gw) == 0);
@@ -1358,8 +1362,9 @@ struct DepositPreauth_test : public beast::unit_test::Suite
             auto const jDelCred = credentials::ledgerEntry(env, zelda, issuer, credType);
             BEAST_EXPECT(
                 jDelCred.isObject() && jDelCred.isMember(jss::result) &&
-                jDelCred[jss::result].isMember(jss::error) &&
-                jDelCred[jss::result][jss::error] == "entryNotFound");
+                jDelCred[jss::result][jss::error] == "entryNotFound" &&
+                jDelCred[jss::result][jss::error_code] == RpcEntryNotFound &&
+                jDelCred[jss::result][jss::error_message] == "Entry not found.");
         }
     }
 

src/test/app/MPToken_test.cpp

@@ -39,6 +39,7 @@
 #include <xrpl/ledger/helpers/MPTokenHelpers.h>
 #include <xrpl/ledger/helpers/TokenHelpers.h>
 #include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/IOUAmount.h>
 #include <xrpl/protocol/Indexes.h>
@@ -1020,6 +1021,7 @@ class MPToken_test : public beast::unit_test::Suite
             payment[jss::build_path] = true;
             auto jrr = env.rpc("json", "submit", to_string(payment));
             BEAST_EXPECT(jrr[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 jrr[jss::result][jss::error_message] ==
                 "Field 'build_path' not allowed in this context.");
@@ -1581,6 +1583,8 @@ class MPToken_test : public beast::unit_test::Suite
             jv[jss::tx_json][jss::Amount][jss::value] = std::to_string(kMaxMpTokenAmount + 1);
             auto const jrr = env.rpc("json", "submit", to_string(jv));
             BEAST_EXPECT(jrr[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::result][jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(jrr[jss::result][jss::error_message] == "Invalid field 'tx_json.Amount'.");
         }
 
         // Pay maximum amount with the transfer fee, SendMax, and
@@ -1945,6 +1949,8 @@ class MPToken_test : public beast::unit_test::Suite
                 jtx.stx->add(s);
                 auto jrr = env.rpc("submit", strHex(s.slice()));
                 BEAST_EXPECT(jrr[jss::result][jss::error] == "invalidTransaction");
+                BEAST_EXPECT(!jrr[jss::result].isMember(jss::error_code));
+                BEAST_EXPECT(jrr[jss::result][jss::error_message].isNull());
 
                 // tx is unsigned
                 json::Value jv1;
@@ -1952,9 +1958,13 @@ class MPToken_test : public beast::unit_test::Suite
                 jv1[jss::tx_json] = jv;
                 jrr = env.rpc("json", "submit", to_string(jv1));
                 BEAST_EXPECT(jrr[jss::result][jss::error] == "invalidParams");
+                BEAST_EXPECT(jrr[jss::result][jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(jrr[jss::result][jss::error_message] == "Amount can not be MPT.");
 
                 jrr = env.rpc("json", "sign", to_string(jv1));
                 BEAST_EXPECT(jrr[jss::result][jss::error] == "invalidParams");
+                BEAST_EXPECT(jrr[jss::result][jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(jrr[jss::result][jss::error_message] == "Amount can not be MPT.");
             };
             auto setMPTFields = [&](SField const& field, json::Value& jv, bool withAmount = true) {
                 jv[jss::Asset] = toJson(xrpIssue());
@@ -3198,6 +3208,9 @@ class MPToken_test : public beast::unit_test::Suite
             jv1[jss::tx_json] = jv;
             auto const jrr = env.rpc("json", "submit", to_string(jv1));
             BEAST_EXPECT(jrr[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::result][jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(
+                jrr[jss::result][jss::error_message] == "Field 'tx_json.Amount' has invalid data.");
         }
     }
 

src/test/app/MultiSign_test.cpp

@@ -31,6 +31,7 @@
 #include <xrpl/config/Constants.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/KeyType.h>
@@ -586,6 +587,7 @@ public:
             auto jrr = env.rpc("json", "sign_for", to_string(jvOne))[jss::result];
             BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 jrr[jss::error_message] ==
                 "When multi-signing 'tx_json.SigningPubKey' must be empty.");
@@ -613,6 +615,7 @@ public:
             jrr = env.rpc("json", "submit_multisigned", to_string(jvSubmit))[jss::result];
             BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 jrr[jss::error_message] == "Invalid Fee field.  Fees must be greater than zero.");
         }
@@ -639,6 +642,7 @@ public:
             jrr = env.rpc("json", "submit_multisigned", to_string(jvSubmit))[jss::result];
             BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "internal");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInternal);
             BEAST_EXPECT(jrr[jss::error_message] == "Internal error.");
         }
 
@@ -651,6 +655,8 @@ public:
             auto jrr = env.rpc("json", "sign_for", to_string(jv))[jss::result];
             BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "masterDisabled");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcMasterDisabled);
+            BEAST_EXPECT(jrr[jss::error_message] == "Master key is disabled.");
             env.close();
             BEAST_EXPECT(env.seq(alice) == aliceSeq);
         }
@@ -690,12 +696,16 @@ public:
             auto jrr = env.rpc("json", "sign_for", to_string(jv))[jss::result];
             BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "srcActMalformed");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcSrcActMalformed);
+            BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'tx_json.Account'.");
 
             Account const jimmy{"jimmy"};
             jv[jss::tx_json][jss::Account] = jimmy.human();
             jrr = env.rpc("json", "sign_for", to_string(jv))[jss::result];
             BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "srcActNotFound");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcSrcActNotFound);
+            BEAST_EXPECT(jrr[jss::error_message] == "Source account not found.");
         }
 
         {
@@ -706,6 +716,7 @@ public:
             auto jrr = env.rpc("json", "submit_multisigned", to_string(jv))[jss::result];
             BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "tx_json.Signers array may not be empty.");
             env.close();
             BEAST_EXPECT(env.seq(alice) == aliceSeq);
@@ -1068,6 +1079,9 @@ public:
             STTx local = *tx.stx;
             local.setFieldVL(sfSigningPubKey, Blob());  // Empty SigningPubKey
             auto const info = submitSTTx(local);
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!info[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(info[jss::result][jss::error_message].isNull());
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
                 "fails local checks: Empty SigningPubKey.");
@@ -1082,6 +1096,9 @@ public:
             local.setFieldVL(sfTxnSignature, badSig);
             // Signature should fail.
             auto const info = submitSTTx(local);
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!info[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(info[jss::result][jss::error_message].isNull());
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
                 "fails local checks: Invalid signature.");
@@ -1095,6 +1112,9 @@ public:
             local.setFieldU32(sfSequence, seq + 1);
             // Signature should fail.
             auto const info = submitSTTx(local);
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!info[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(info[jss::result][jss::error_message].isNull());
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
                 "fails local checks: Invalid signature.");
@@ -1105,6 +1125,9 @@ public:
             STTx local = *tx.stx;
             local[sfSigningPubKey] = alice.pk();  // Insert sfSigningPubKey
             auto const info = submitSTTx(local);
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!info[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(info[jss::result][jss::error_message].isNull());
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
                 "fails local checks: Cannot both single- and multi-sign.");
@@ -1116,6 +1139,9 @@ public:
             local.sign(alice.pk(), alice.sk());
             local.setFieldVL(sfSigningPubKey, Blob());  // Empty SigningPubKey
             auto const info = submitSTTx(local);
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!info[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(info[jss::result][jss::error_message].isNull());
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
                 "fails local checks: Cannot both single- and multi-sign.");
@@ -1131,6 +1157,9 @@ public:
             signer.setFieldVL(sfTxnSignature, badSig);
             // Signature should fail.
             auto const info = submitSTTx(local);
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!info[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(info[jss::result][jss::error_message].isNull());
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception].asString().contains(
                     "Invalid signature on account r"));
@@ -1141,6 +1170,9 @@ public:
             STTx local = *tx.stx;
             local.peekFieldArray(sfSigners).clear();  // Empty Signers array.
             auto const info = submitSTTx(local);
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!info[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(info[jss::result][jss::error_message].isNull());
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
                 "fails local checks: Invalid Signers array size.");
@@ -1186,6 +1218,9 @@ public:
                     bogie_));
             STTx const local = *tx.stx;
             auto const info = submitSTTx(local);
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!info[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(info[jss::result][jss::error_message].isNull());
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
                 "fails local checks: Invalid Signers array size.");
@@ -1195,6 +1230,9 @@ public:
             JTx const tx = env.jt(noop(alice), Fee(2 * baseFee), Msig(alice));
             STTx const local = *tx.stx;
             auto const info = submitSTTx(local);
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!info[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(info[jss::result][jss::error_message].isNull());
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
                 "fails local checks: Invalid multisigner.");
@@ -1204,6 +1242,9 @@ public:
             JTx const tx = env.jt(noop(alice), Fee(2 * baseFee), Msig(bogie_, bogie_));
             STTx const local = *tx.stx;
             auto const info = submitSTTx(local);
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!info[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(info[jss::result][jss::error_message].isNull());
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
                 "fails local checks: Duplicate Signers not allowed.");
@@ -1217,6 +1258,9 @@ public:
             std::ranges::reverse(signers);
             // Signature should fail.
             auto const info = submitSTTx(local);
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!info[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(info[jss::result][jss::error_message].isNull());
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
                 "fails local checks: Unsorted Signers array.");

src/test/app/NFToken_test.cpp

@@ -30,6 +30,7 @@
 #include <xrpl/json/to_string.h>
 #include <xrpl/ledger/OpenView.h>
 #include <xrpl/protocol/ApiVersion.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Protocol.h>
@@ -4653,18 +4654,22 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite
                     if (expect(
                             nftOffers.isMember(jss::result), "expected \"result\"", __FILE__, line))
                     {
-                        if (expect(
-                                nftOffers[jss::result].isMember(jss::error),
-                                "expected \"error\"",
-                                __FILE__,
-                                line))
-                        {
-                            expect(
-                                nftOffers[jss::result][jss::error].asString() == "objectNotFound",
-                                "expected \"objectNotFound\"",
-                                __FILE__,
-                                line);
-                        }
+                        json::Value const& result = nftOffers[jss::result];
+                        expect(
+                            result[jss::error].asString() == "objectNotFound",
+                            "expected \"objectNotFound\"",
+                            __FILE__,
+                            line);
+                        expect(
+                            result[jss::error_code] == RpcObjectNotFound,
+                            "expected RpcObjectNotFound",
+                            __FILE__,
+                            line);
+                        expect(
+                            result[jss::error_message] == "The requested object was not found.",
+                            "expected \"The requested object was not found.\"",
+                            __FILE__,
+                            line);
                     }
                     break;
                 }
@@ -4860,11 +4865,15 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite
             // Sell-side marker passed to nft_buy_offers.
             json::Value const result = queryWithMarker("nft_buy_offers", sellOfferIndex);
             BEAST_EXPECT(result[jss::error].asString() == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(result[jss::error_message] == "Invalid parameters.");
         }
         {
             // Buy-side marker passed to nft_sell_offers.
             json::Value const result = queryWithMarker("nft_sell_offers", buyOfferIndex);
             BEAST_EXPECT(result[jss::error].asString() == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(result[jss::error_message] == "Invalid parameters.");
         }
 
         // A same-side marker is still accepted.  With a single offer on each

src/test/app/OfferMPT_test.cpp

@@ -34,6 +34,7 @@
 #include <xrpl/ledger/helpers/DirectoryHelpers.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Book.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
@@ -2755,6 +2756,8 @@ public:
 
         jro = ledgerEntryOffer(env, bob, bobOfferSeq);
         BEAST_EXPECT(jro[jss::error] == "entryNotFound");
+        BEAST_EXPECT(jro[jss::error_code] == RpcEntryNotFound);
+        BEAST_EXPECT(jro[jss::error_message] == "Entry not found.");
 
         env.require(Owners(alice, 1), Owners(bob, 1));
     }
@@ -2788,6 +2791,8 @@ public:
 
             auto jro = ledgerEntryOffer(env, bob, bobOfferSeq);
             BEAST_EXPECT(jro[jss::error] == "entryNotFound");
+            BEAST_EXPECT(jro[jss::error_code] == RpcEntryNotFound);
+            BEAST_EXPECT(jro[jss::error_message] == "Entry not found.");
         };
         testHelper3TokensMix(test);
     }
@@ -2847,6 +2852,8 @@ public:
         // Verify the offer was consumed
         jro = ledgerEntryOffer(env, bob, bobOfferSeq);
         BEAST_EXPECT(jro[jss::error] == "entryNotFound");
+        BEAST_EXPECT(jro[jss::error_code] == RpcEntryNotFound);
+        BEAST_EXPECT(jro[jss::error_message] == "Entry not found.");
 
         // verify balances look right after the partial payment
         // only 300 XRP should have been payed since that's all

src/test/app/Offer_test.cpp

@@ -30,6 +30,7 @@
 #include <xrpl/json/to_string.h>
 #include <xrpl/ledger/helpers/DirectoryHelpers.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
@@ -1707,6 +1708,8 @@ public:
 
         jro = ledgerEntryOffer(env, bob, bobOfferSeq);
         BEAST_EXPECT(jro[jss::error] == "entryNotFound");
+        BEAST_EXPECT(jro[jss::error_code] == RpcEntryNotFound);
+        BEAST_EXPECT(jro[jss::error_message] == "Entry not found.");
 
         env.require(Owners(alice, 1), Owners(bob, 1));
     }
@@ -1738,6 +1741,8 @@ public:
 
         auto jro = ledgerEntryOffer(env, bob, bobOfferSeq);
         BEAST_EXPECT(jro[jss::error] == "entryNotFound");
+        BEAST_EXPECT(jro[jss::error_code] == RpcEntryNotFound);
+        BEAST_EXPECT(jro[jss::error_message] == "Entry not found.");
     }
 
     void
@@ -1798,6 +1803,8 @@ public:
         // Verify the offer was consumed
         jro = ledgerEntryOffer(env, bob, bobOfferSeq);
         BEAST_EXPECT(jro[jss::error] == "entryNotFound");
+        BEAST_EXPECT(jro[jss::error_code] == RpcEntryNotFound);
+        BEAST_EXPECT(jro[jss::error_message] == "Entry not found.");
 
         // verify balances look right after the partial payment
         // only 300 XRP should be have been payed since that's all

src/test/app/PathMPT_test.cpp

@@ -26,6 +26,7 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/ApiVersion.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/PathAsset.h>
 #include <xrpl/protocol/SField.h>
@@ -162,7 +163,9 @@ public:
             g.signal();
         });
         BEAST_EXPECT(g.waitFor(5s));
-        BEAST_EXPECT(result.isMember(jss::error));
+        BEAST_EXPECT(result[jss::error] == "srcCurMalformed");
+        BEAST_EXPECT(result[jss::error_code] == RpcSrcCurMalformed);
+        BEAST_EXPECT(result[jss::error_message] == "Source currency is malformed.");
 
         // Test rpc::tuning::max_auto_src_cur source currencies.
         numSrc.clear();
@@ -189,7 +192,9 @@ public:
             g.signal();
         });
         BEAST_EXPECT(g.waitFor(5s));
-        BEAST_EXPECT(result.isMember(jss::error));
+        BEAST_EXPECT(result[jss::error] == "internal");
+        BEAST_EXPECT(result[jss::error_code] == RpcInternal);
+        BEAST_EXPECT(result[jss::error_message] == "Internal error.");
     }
 
     void

src/test/app/Path_test.cpp

@@ -33,6 +33,7 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/ApiVersion.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/SField.h>
@@ -318,7 +319,9 @@ public:
             g.signal();
         });
         BEAST_EXPECT(g.waitFor(5s));
-        BEAST_EXPECT(result.isMember(jss::error));
+        BEAST_EXPECT(result[jss::error] == "srcCurMalformed");
+        BEAST_EXPECT(result[jss::error_code] == RpcSrcCurMalformed);
+        BEAST_EXPECT(result[jss::error_message] == "Source currency is malformed.");
 
         // Test rpc::tuning::max_auto_src_cur source currencies.
         for (auto i = 0; i < (rpc::tuning::kMaxAutoSrcCur - 1); ++i)
@@ -341,7 +344,9 @@ public:
             g.signal();
         });
         BEAST_EXPECT(g.waitFor(5s));
-        BEAST_EXPECT(result.isMember(jss::error));
+        BEAST_EXPECT(result[jss::error] == "internal");
+        BEAST_EXPECT(result[jss::error_code] == RpcInternal);
+        BEAST_EXPECT(result[jss::error_message] == "Internal error.");
     }
 
     void

src/test/app/PayChan_test.cpp

@@ -1058,6 +1058,7 @@ struct PayChan_test : public beast::unit_test::Suite
             auto const jrr = env.rpc("json", "account_channels", to_string(params))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "actMalformed");
             BEAST_EXPECT(jrr[jss::error_code] == RpcActMalformed);
+            BEAST_EXPECT(jrr[jss::error_message] == "Account malformed.");
             BEAST_EXPECT(!jrr.isMember(jss::ledger_index));
             BEAST_EXPECT(!jrr.isMember(jss::ledger_current_index));
         }
@@ -1232,7 +1233,9 @@ struct PayChan_test : public beast::unit_test::Suite
         {
             // degenerate case
             auto const r = testLimit(env, alice, 0);
-            BEAST_EXPECT(r.isMember(jss::error_message));
+            BEAST_EXPECT(r[jss::error] == "invalidParams");
+            BEAST_EXPECT(r[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(r[jss::error_message] == "Invalid field 'limit'.");
         }
 
         {
@@ -1326,7 +1329,12 @@ struct PayChan_test : public beast::unit_test::Suite
             auto const rs =
                 env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
             auto const error = apiVersion < 2u ? "invalidParams" : "badKeyType";
+            auto const errorCode = apiVersion < 2u ? RpcInvalidParams : RpcBadKeyType;
+            auto const errorMessage =
+                apiVersion < 2u ? "Invalid field 'key_type'." : "Bad key type.";
             BEAST_EXPECT(rs[jss::error] == error);
+            BEAST_EXPECT(rs[jss::error_code] == errorCode);
+            BEAST_EXPECT(rs[jss::error_message] == errorMessage);
         });
     }
 
@@ -1415,22 +1423,40 @@ struct PayChan_test : public beast::unit_test::Suite
                 auto const pkAsHex = sliceToHex(pk.slice());
                 auto rv = env.rpc("channel_verify", pkAsHex, chan1Str, "1000x", sig);
                 BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel amount is malformed.");
                 rv = env.rpc("channel_verify", pkAsHex, chan1Str, "1000 ", sig);
                 BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel amount is malformed.");
                 rv = env.rpc("channel_verify", pkAsHex, chan1Str, "x1000", sig);
                 BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel amount is malformed.");
                 rv = env.rpc("channel_verify", pkAsHex, chan1Str, "x", sig);
                 BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel amount is malformed.");
                 rv = env.rpc("channel_verify", pkAsHex, chan1Str, " ", sig);
                 BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel amount is malformed.");
                 rv = env.rpc("channel_verify", pkAsHex, chan1Str, "1000 1000", sig);
                 BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel amount is malformed.");
                 rv = env.rpc("channel_verify", pkAsHex, chan1Str, "1,000", sig);
                 BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel amount is malformed.");
                 rv = env.rpc("channel_verify", pkAsHex, chan1Str, " 1000", sig);
                 BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel amount is malformed.");
                 rv = env.rpc("channel_verify", pkAsHex, chan1Str, "", sig);
                 BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel amount is malformed.");
             }
             {
                 // malformed channel
@@ -1439,22 +1465,34 @@ struct PayChan_test : public beast::unit_test::Suite
                 chan1StrBad.pop_back();
                 auto rv = env.rpc("channel_verify", pkAsHex, chan1StrBad, "1000", sig);
                 BEAST_EXPECT(rv[jss::error] == "channelMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel is malformed.");
                 rv = env.rpc("channel_authorize", "alice", chan1StrBad, "1000");
                 BEAST_EXPECT(rv[jss::error] == "channelMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel is malformed.");
 
                 chan1StrBad = chan1Str;
                 chan1StrBad.push_back('0');
                 rv = env.rpc("channel_verify", pkAsHex, chan1StrBad, "1000", sig);
                 BEAST_EXPECT(rv[jss::error] == "channelMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel is malformed.");
                 rv = env.rpc("channel_authorize", "alice", chan1StrBad, "1000");
                 BEAST_EXPECT(rv[jss::error] == "channelMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel is malformed.");
 
                 chan1StrBad = chan1Str;
                 chan1StrBad.back() = 'x';
                 rv = env.rpc("channel_verify", pkAsHex, chan1StrBad, "1000", sig);
                 BEAST_EXPECT(rv[jss::error] == "channelMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel is malformed.");
                 rv = env.rpc("channel_authorize", "alice", chan1StrBad, "1000");
                 BEAST_EXPECT(rv[jss::error] == "channelMalformed");
+                BEAST_EXPECT(rv[jss::error_code] == RpcChannelMalformed);
+                BEAST_EXPECT(rv[jss::error_message] == "Payment channel is malformed.");
             }
             {
                 // channel_id is not a string.
@@ -1467,6 +1505,8 @@ struct PayChan_test : public beast::unit_test::Suite
                 auto const ra =
                     env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
                 BEAST_EXPECT(ra[jss::error] == "invalidParams");
+                BEAST_EXPECT(ra[jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(ra[jss::error_message] == "Invalid parameters.");
             }
             {
                 // channel_id is not a string.
@@ -1479,6 +1519,8 @@ struct PayChan_test : public beast::unit_test::Suite
                 auto const rv =
                     env.rpc("json", "channel_verify", args.toStyledString())[jss::result];
                 BEAST_EXPECT(rv[jss::error] == "invalidParams");
+                BEAST_EXPECT(rv[jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(rv[jss::error_message] == "Invalid parameters.");
             }
             {
                 // give an ill formed base 58 public key
@@ -1537,6 +1579,8 @@ struct PayChan_test : public beast::unit_test::Suite
             // Try to authorize using an unknown key type, except an error:
             auto const rs1 = env.rpc("channel_authorize", "charlie", "nyx", chan, "1000");
             BEAST_EXPECT(rs1[jss::error] == "badKeyType");
+            BEAST_EXPECT(rs1[jss::error_code] == RpcBadKeyType);
+            BEAST_EXPECT(rs1[jss::error_message] == "Bad key type.");
 
             // Try to authorize using secp256k1; the authorization _should_
             // succeed but the verification should fail:
@@ -1562,10 +1606,16 @@ struct PayChan_test : public beast::unit_test::Suite
             // send malformed amounts rpc requests
             auto rs = env.rpc("channel_authorize", "alice", chan1Str, "1000x");
             BEAST_EXPECT(rs[jss::error] == "channelAmtMalformed");
+            BEAST_EXPECT(rs[jss::error_code] == RpcChannelAmtMalformed);
+            BEAST_EXPECT(rs[jss::error_message] == "Payment channel amount is malformed.");
             rs = env.rpc("channel_authorize", "alice", chan1Str, "x1000");
             BEAST_EXPECT(rs[jss::error] == "channelAmtMalformed");
+            BEAST_EXPECT(rs[jss::error_code] == RpcChannelAmtMalformed);
+            BEAST_EXPECT(rs[jss::error_message] == "Payment channel amount is malformed.");
             rs = env.rpc("channel_authorize", "alice", chan1Str, "x");
             BEAST_EXPECT(rs[jss::error] == "channelAmtMalformed");
+            BEAST_EXPECT(rs[jss::error_code] == RpcChannelAmtMalformed);
+            BEAST_EXPECT(rs[jss::error_message] == "Payment channel amount is malformed.");
             {
                 // Missing channel_id
                 json::Value args{json::ValueType::Object};
@@ -1574,6 +1624,8 @@ struct PayChan_test : public beast::unit_test::Suite
                 args[jss::passphrase] = "passphrase_can_be_anything";
                 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
                 BEAST_EXPECT(rs[jss::error] == "invalidParams");
+                BEAST_EXPECT(rs[jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(rs[jss::error_message] == "Missing field 'channel_id'.");
             }
             {
                 // Missing amount
@@ -1583,6 +1635,8 @@ struct PayChan_test : public beast::unit_test::Suite
                 args[jss::passphrase] = "passphrase_can_be_anything";
                 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
                 BEAST_EXPECT(rs[jss::error] == "invalidParams");
+                BEAST_EXPECT(rs[jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(rs[jss::error_message] == "Missing field 'amount'.");
             }
             {
                 // Missing key_type and no secret.
@@ -1592,6 +1646,8 @@ struct PayChan_test : public beast::unit_test::Suite
                 args[jss::passphrase] = "passphrase_can_be_anything";
                 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
                 BEAST_EXPECT(rs[jss::error] == "invalidParams");
+                BEAST_EXPECT(rs[jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(rs[jss::error_message] == "Missing field 'secret'.");
             }
             {
                 // Both passphrase and seed specified.
@@ -1603,6 +1659,11 @@ struct PayChan_test : public beast::unit_test::Suite
                 args[jss::seed] = "seed can be anything";
                 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
                 BEAST_EXPECT(rs[jss::error] == "invalidParams");
+                BEAST_EXPECT(rs[jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(
+                    rs[jss::error_message] ==
+                    "Exactly one of the following must be specified: passphrase, secret, seed or "
+                    "seed_hex");
             }
             {
                 // channel_id is not exact hex.
@@ -1613,6 +1674,8 @@ struct PayChan_test : public beast::unit_test::Suite
                 args[jss::passphrase] = "passphrase_can_be_anything";
                 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
                 BEAST_EXPECT(rs[jss::error] == "channelMalformed");
+                BEAST_EXPECT(rs[jss::error_code] == RpcChannelMalformed);
+                BEAST_EXPECT(rs[jss::error_message] == "Payment channel is malformed.");
             }
             {
                 // amount is not a string
@@ -1623,6 +1686,8 @@ struct PayChan_test : public beast::unit_test::Suite
                 args[jss::passphrase] = "passphrase_can_be_anything";
                 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
                 BEAST_EXPECT(rs[jss::error] == "channelAmtMalformed");
+                BEAST_EXPECT(rs[jss::error_code] == RpcChannelAmtMalformed);
+                BEAST_EXPECT(rs[jss::error_message] == "Payment channel amount is malformed.");
             }
             {
                 // Amount is not a decimal string.
@@ -1633,6 +1698,8 @@ struct PayChan_test : public beast::unit_test::Suite
                 args[jss::passphrase] = "passphrase_can_be_anything";
                 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
                 BEAST_EXPECT(rs[jss::error] == "channelAmtMalformed");
+                BEAST_EXPECT(rs[jss::error_code] == RpcChannelAmtMalformed);
+                BEAST_EXPECT(rs[jss::error_message] == "Payment channel amount is malformed.");
             }
         }
     }
@@ -1883,6 +1950,8 @@ struct PayChan_test : public beast::unit_test::Suite
         )*";
             auto const r = env.rpc("json", "channel_verify", txn);
             BEAST_EXPECT(r["result"]["error"] == "publicMalformed");
+            BEAST_EXPECT(r["result"]["error_code"] == RpcPublicMalformed);
+            BEAST_EXPECT(r["result"]["error_message"] == "Public key is malformed.");
         }
     }
 

src/test/app/ReducedOffer_test.cpp

@@ -13,6 +13,7 @@
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Quality.h>
 #include <xrpl/protocol/SField.h>
@@ -42,8 +43,9 @@ class ReducedOffer_test : public beast::unit_test::Suite
     {
         json::Value ledgerOffer = ledgerEntryOffer(env, acct, offerSeq);
         return !(
-            ledgerOffer.isMember(jss::error) &&
-            ledgerOffer[jss::error].asString() == "entryNotFound");
+            ledgerOffer[jss::error].asString() == "entryNotFound" &&
+            ledgerOffer[jss::error_code] == RpcEntryNotFound &&
+            ledgerOffer[jss::error_message] == "Entry not found.");
     }
 
     // Common code to clean up unneeded offers.

src/test/app/SHAMapStore_test.cpp

@@ -302,10 +302,14 @@ class SHAMapStore_test : public beast::unit_test::Suite
     }
 
     static bool
-    bad(json::Value const& json, ErrorCodeI error = RpcLgrNotFound)
+    bad(json::Value const& json,
+        std::string const& token,
+        ErrorCodeI error,
+        std::string const& message)
     {
-        return json.isMember(jss::result) && rpc::containsError(json[jss::result]) &&
-            json[jss::result][jss::error_code] == error;
+        return json.isMember(jss::result) && json[jss::result][jss::error] == token &&
+            json[jss::result][jss::error_code] == error &&
+            json[jss::result][jss::error_message] == message;
     }
 
     std::string
@@ -883,7 +887,7 @@ public:
         std::map<std::uint32_t, json::Value const> ledgers;
 
         auto ledgerTmp = env.rpc("ledger", "0");
-        BEAST_EXPECT(bad(ledgerTmp));
+        BEAST_EXPECT(bad(ledgerTmp, "lgrNotFound", RpcLgrNotFound, "ledgerNotFound"));
 
         ledgers.emplace(1, env.rpc("ledger", "1"));
         BEAST_EXPECT(goodLedger(env, ledgers[1], "1"));
@@ -895,10 +899,10 @@ public:
         BEAST_EXPECT(goodLedger(env, ledgerTmp, "3"));
 
         ledgerTmp = env.rpc("ledger", "4");
-        BEAST_EXPECT(bad(ledgerTmp));
+        BEAST_EXPECT(bad(ledgerTmp, "lgrNotFound", RpcLgrNotFound, "ledgerNotFound"));
 
         ledgerTmp = env.rpc("ledger", "100");
-        BEAST_EXPECT(bad(ledgerTmp));
+        BEAST_EXPECT(bad(ledgerTmp, "lgrNotFound", RpcLgrNotFound, "ledgerNotFound"));
 
         auto const firstSeq = waitForReady(env);
         auto lastRotated = firstSeq - 1;
@@ -987,7 +991,7 @@ public:
         // Because advisory_delete is unset,
         // "can_delete" is disabled.
         auto const canDelete = env.rpc("can_delete");
-        BEAST_EXPECT(bad(canDelete, RpcNotEnabled));
+        BEAST_EXPECT(bad(canDelete, "notEnabled", RpcNotEnabled, "Not enabled in configuration."));
 
         // Close ledgers without triggering a rotate
         for (; ledgerSeq < lastRotated + kDeleteInterval; ++ledgerSeq)

src/test/app/TransactionProposalCancel_test.cpp

@@ -20,6 +20,7 @@
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Protocol.h>
@@ -1032,15 +1033,25 @@ struct TransactionProposalCancel_test : public beast::unit_test::Suite
         {
             json::Value noTicket;
             noTicket[jss::account] = target.human();
-            BEAST_EXPECT(ledgerEntry(noTicket)[jss::error] == "malformedRequest");
+            auto const noTicketResult = ledgerEntry(noTicket);
+            BEAST_EXPECT(noTicketResult[jss::error] == "malformedRequest");
+            BEAST_EXPECT(noTicketResult[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(noTicketResult[jss::error_message] == "Missing field 'ticket_seq'.");
 
             json::Value noAccount;
             noAccount[jss::ticket_seq] = ticketSeq;
-            BEAST_EXPECT(ledgerEntry(noAccount)[jss::error] == "malformedRequest");
+            auto const noAccountResult = ledgerEntry(noAccount);
+            BEAST_EXPECT(noAccountResult[jss::error] == "malformedRequest");
+            BEAST_EXPECT(noAccountResult[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(noAccountResult[jss::error_message] == "Missing field 'account'.");
 
             json::Value badAccount = byPair;
             badAccount[jss::account] = "not an account";
-            BEAST_EXPECT(ledgerEntry(badAccount)[jss::error] == "malformedAddress");
+            auto const badAccountResult = ledgerEntry(badAccount);
+            BEAST_EXPECT(badAccountResult[jss::error] == "malformedAddress");
+            BEAST_EXPECT(badAccountResult[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(
+                badAccountResult[jss::error_message] == "Invalid field 'account', not AccountID.");
         }
 
         // Listed for the proposer, who owns it, and not for the target.
@@ -1057,6 +1068,8 @@ struct TransactionProposalCancel_test : public beast::unit_test::Suite
         {
             auto const jrr = ledgerEntry(byPair);
             BEAST_EXPECT(jrr[jss::error] == "entryNotFound");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcEntryNotFound);
+            BEAST_EXPECT(jrr[jss::error_message] == "Entry not found.");
             BEAST_EXPECT(!jrr.isMember(jss::node));
             BEAST_EXPECT(jrr[jss::index] == to_string(proposalID));
         }

src/test/app/TrustAndBalance_test.cpp

@@ -14,6 +14,7 @@
 #include <xrpl/basics/strHex.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_value.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/TER.h>
@@ -66,6 +67,8 @@ class TrustAndBalance_test : public beast::unit_test::Suite
         // reflects this
         auto jrr = ledgerEntryState(env, gw, alice, "USD");
         BEAST_EXPECT(jrr[jss::error] == "entryNotFound");
+        BEAST_EXPECT(jrr[jss::error_code] == RpcEntryNotFound);
+        BEAST_EXPECT(jrr[jss::error_message] == "Entry not found.");
 
         // now create a credit limit
         env(trust(alice, gw["USD"](800)));
@@ -100,6 +103,8 @@ class TrustAndBalance_test : public beast::unit_test::Suite
         // ensure line is deleted
         jrr = ledgerEntryState(env, gw, alice, "USD");
         BEAST_EXPECT(jrr[jss::error] == "entryNotFound");
+        BEAST_EXPECT(jrr[jss::error_code] == RpcEntryNotFound);
+        BEAST_EXPECT(jrr[jss::error_message] == "Entry not found.");
 
         // TODO Check in both owner books.
 

src/test/app/TxQ_test.cpp

@@ -3231,7 +3231,9 @@ public:
 
         {
             auto const info = env.rpc("json", "account_info", to_string(prevLedgerWithQueue));
-            BEAST_EXPECT(info.isMember(jss::result) && rpc::containsError(info[jss::result]));
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(info[jss::result][jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(info[jss::result][jss::error_message] == "Invalid parameters.");
         }
 
         env.close();

src/test/app/lending/LoanBroker_test.cpp

@@ -1154,6 +1154,8 @@ class LoanBroker_test : public beast::unit_test::Suite
             auto const jrr = env.rpc("submit", strHex(s.slice()))[jss::result];
             // fails in doSubmit() on STTx construction
             BEAST_EXPECT(jrr[jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!jrr.isMember(jss::error_code));
+            BEAST_EXPECT(jrr[jss::error_message].isNull());
             BEAST_EXPECT(jrr[jss::error_exception] == "invalid native account");
         }
 

src/test/app/lending/LoanLifecycle_test.cpp

@@ -190,6 +190,8 @@ private:
             BEAST_EXPECT(jr.isMember(jss::result));
             auto const jResult = jr[jss::result];
             BEAST_EXPECT(jResult[jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!jResult.isMember(jss::error_code));
+            BEAST_EXPECT(jResult[jss::error_message].isNull());
             BEAST_EXPECT(
                 jResult[jss::error_exception] ==
                 "fails local checks: Transaction has bad signature.");

src/test/app/lending/LoanMisc_test.cpp

@@ -18,6 +18,7 @@
 #include <xrpl/beast/xor_shift_engine.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/KeyType.h>
@@ -126,12 +127,9 @@ private:
                     return params;
                 }();
                 auto const jSignBorrower = env.rpc("json", "sign", to_string(borrowerSignParams));
-                BEAST_EXPECT(
-                    jSignBorrower.isMember(jss::result) &&
-                    jSignBorrower[jss::result].isMember(jss::error) &&
-                    jSignBorrower[jss::result][jss::error] == "invalidParams" &&
-                    jSignBorrower[jss::result].isMember(jss::error_message) &&
-                    jSignBorrower[jss::result][jss::error_message] == target);
+                BEAST_EXPECT(jSignBorrower[jss::result][jss::error] == "invalidParams");
+                BEAST_EXPECT(jSignBorrower[jss::result][jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(jSignBorrower[jss::result][jss::error_message] == target);
             }
         }
         {

src/test/app/lending/LoanValidation_test.cpp

@@ -196,7 +196,8 @@ private:
             jvResult[jss::tx_blob] = strHex(local.getSerializer().slice());
             auto res = env.rpc("json", "submit", to_string(jvResult))["result"];
             BEAST_EXPECT(
-                res[jss::error] == "invalidTransaction" &&
+                res[jss::error] == "invalidTransaction" && !res.isMember(jss::error_code) &&
+                res[jss::error_message].isNull() &&
                 res[jss::error_exception] ==
                     "fails local checks: Counterparty: Invalid signature.");
         });

src/test/app/vault/VaultRPC_test.cpp

@@ -172,7 +172,7 @@ private:
             jvParams[jss::ledger_index] = jss::validated;
             jvParams[jss::vault] = to_string(UInt256(42));
             auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
-            BEAST_EXPECT(jvVault[jss::result][jss::error].asString() == "entryNotFound");
+            checkError(jvVault[jss::result], "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
 
         {
@@ -182,7 +182,7 @@ private:
             jvParams[jss::vault][jss::owner] = issuer.human();
             jvParams[jss::vault][jss::seq] = 1'000'000;
             auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
-            BEAST_EXPECT(jvVault[jss::result][jss::error].asString() == "entryNotFound");
+            checkError(jvVault[jss::result], "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
 
         {
@@ -191,7 +191,11 @@ private:
             jvParams[jss::ledger_index] = jss::validated;
             jvParams[jss::vault] = 42;
             auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
-            BEAST_EXPECT(jvVault[jss::result][jss::error].asString() == "malformedRequest");
+            checkError(
+                jvVault[jss::result],
+                "malformedRequest",
+                RpcInvalidParams,
+                "Invalid field 'vault', not hex string or object.");
         }
 
         {
@@ -201,7 +205,11 @@ private:
             jvParams[jss::vault][jss::owner] = 42;
             jvParams[jss::vault][jss::seq] = sequence;
             auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
-            BEAST_EXPECT(jvVault[jss::result][jss::error].asString() == "malformedOwner");
+            checkError(
+                jvVault[jss::result],
+                "malformedOwner",
+                RpcInvalidParams,
+                "Invalid field 'owner', not AccountID.");
         }
 
         {
@@ -211,7 +219,11 @@ private:
             jvParams[jss::vault][jss::owner] = issuer.human();
             jvParams[jss::vault][jss::seq] = "foo";
             auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
-            BEAST_EXPECT(jvVault[jss::result][jss::error].asString() == "malformedRequest");
+            checkError(
+                jvVault[jss::result],
+                "malformedRequest",
+                RpcInvalidParams,
+                "Invalid field 'seq', not number.");
         }
 
         {
@@ -221,7 +233,11 @@ private:
             jvParams[jss::vault][jss::owner] = issuer.human();
             jvParams[jss::vault][jss::seq] = -1;
             auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
-            BEAST_EXPECT(jvVault[jss::result][jss::error].asString() == "malformedRequest");
+            checkError(
+                jvVault[jss::result],
+                "malformedRequest",
+                RpcInvalidParams,
+                "Invalid field 'seq', not number.");
         }
 
         {
@@ -231,7 +247,11 @@ private:
             jvParams[jss::vault][jss::owner] = issuer.human();
             jvParams[jss::vault][jss::seq] = 1e20;
             auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
-            BEAST_EXPECT(jvVault[jss::result][jss::error].asString() == "malformedRequest");
+            checkError(
+                jvVault[jss::result],
+                "malformedRequest",
+                RpcInvalidParams,
+                "Invalid field 'seq', not number.");
         }
 
         {
@@ -241,7 +261,11 @@ private:
             jvParams[jss::vault][jss::owner] = issuer.human();
             jvParams[jss::vault][jss::seq] = true;
             auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
-            BEAST_EXPECT(jvVault[jss::result][jss::error].asString() == "malformedRequest");
+            checkError(
+                jvVault[jss::result],
+                "malformedRequest",
+                RpcInvalidParams,
+                "Invalid field 'seq', not number.");
         }
 
         {
@@ -500,8 +524,8 @@ private:
 
         {
             testcase("RPC vault_info command line invalid index");
-            json::Value jv = env.rpc("vault_info", "foobar", "validated");
-            BEAST_EXPECT(jv[jss::error].asString() == "invalidParams");
+            json::Value const jv = env.rpc("vault_info", "foobar", "validated");
+            checkError(jv, "invalidParams", RpcInvalidParams, "Invalid parameters.");
         }
 
         {
@@ -519,7 +543,7 @@ private:
         {
             testcase("RPC vault_info command line invalid ledger");
             json::Value jv = env.rpc("vault_info", strHex(keylet.key), "0");
-            BEAST_EXPECT(jv[jss::result][jss::error].asString() == "lgrNotFound");
+            checkError(jv[jss::result], "lgrNotFound", RpcLgrNotFound, "ledgerNotFound");
         }
     }
 

src/test/protocol/STIssue_test.cpp

@@ -12,6 +12,7 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/MPTIssue.h>
@@ -180,6 +181,7 @@ public:
         auto const result = env.rpc("json", "sign", to_string(req))[jss::result];
 
         BEAST_EXPECT(result[jss::error] == "invalidParams");
+        BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
         BEAST_EXPECT(result[jss::error_message] == "Field 'tx_json.Asset' has invalid data.");
     }
 
@@ -253,6 +255,7 @@ public:
         auto const result = env.rpc("json", "sign", to_string(req))[jss::result];
 
         BEAST_EXPECT(result[jss::error] == "invalidParams");
+        BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
         BEAST_EXPECT(result[jss::error_message] == "Field 'tx_json.Asset' has invalid data.");
     }
 

src/test/rpc/AMMInfo_test.cpp

@@ -8,6 +8,7 @@
 
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/TxFlags.h>
@@ -56,12 +57,16 @@ public:
             Account const gw("gw");
             auto const usd = gw["USD"];
             auto const jv = ammAlice.ammRpcInfo({}, {}, usd, usd);
+            BEAST_EXPECT(jv[jss::error] == "actNotFound");
+            BEAST_EXPECT(jv[jss::error_code] == RpcActNotFound);
             BEAST_EXPECT(jv[jss::error_message] == "Account not found.");
         });
 
         // Invalid LP account id
         testAMM([&](AMM& ammAlice, Env&) {
             auto const jv = ammAlice.ammRpcInfo(bogie.id());
+            BEAST_EXPECT(jv[jss::error] == "actMalformed");
+            BEAST_EXPECT(jv[jss::error_code] == RpcActMalformed);
             BEAST_EXPECT(jv[jss::error_message] == "Account malformed.");
         });
 
@@ -69,6 +74,8 @@ public:
         testAMM([&](AMM& ammAlice, Env&) {
             auto const jv =
                 ammAlice.ammRpcInfo(json::Value{42}, std::nullopt, XRP, USD, std::nullopt, true, 3);
+            BEAST_EXPECT(jv[jss::error] == "actMalformed");
+            BEAST_EXPECT(jv[jss::error_code] == RpcActMalformed);
             BEAST_EXPECT(jv[jss::error_message] == "Account malformed.");
         });
 
@@ -82,6 +89,8 @@ public:
                 json::Value{42},
                 false,
                 3);
+            BEAST_EXPECT(jv[jss::error] == "actMalformed");
+            BEAST_EXPECT(jv[jss::error_code] == RpcActMalformed);
             BEAST_EXPECT(jv[jss::error_message] == "Account malformed.");
         });
 
@@ -106,6 +115,8 @@ public:
                     iss2,
                     accountId(ammAlice, acct),
                     ignoreParams);
+                BEAST_EXPECT(jv[jss::error] == "invalidParams");
+                BEAST_EXPECT(jv[jss::error_code] == RpcInvalidParams);
                 BEAST_EXPECT(jv[jss::error_message] == "Invalid parameters.");
             }
         });
@@ -121,6 +132,8 @@ public:
                     iss2,
                     accountId(ammAlice, acct),
                     ignoreParams);
+                BEAST_EXPECT(jv[jss::error] == "invalidParams");
+                BEAST_EXPECT(jv[jss::error_code] == RpcInvalidParams);
                 BEAST_EXPECT(jv[jss::error_message] == "Invalid parameters.");
             }
         });
@@ -137,6 +150,8 @@ public:
                     accountId(ammAlice, acct),
                     ignoreParams,
                     3);
+                BEAST_EXPECT(jv[jss::error] == "actMalformed");
+                BEAST_EXPECT(jv[jss::error_code] == RpcActMalformed);
                 BEAST_EXPECT(jv[jss::error_message] == "Account malformed.");
             }
         });
@@ -145,6 +160,8 @@ public:
         testAMM([&](AMM& ammAlice, Env&) {
             auto const jv = ammAlice.ammRpcInfo(
                 std::nullopt, std::nullopt, std::nullopt, std::nullopt, bogie.id());
+            BEAST_EXPECT(jv[jss::error] == "actMalformed");
+            BEAST_EXPECT(jv[jss::error_code] == RpcActMalformed);
             BEAST_EXPECT(jv[jss::error_message] == "Account malformed.");
         });
 
@@ -169,6 +186,8 @@ public:
                     iss2,
                     accountId(ammAlice, acct),
                     ignoreParams);
+                BEAST_EXPECT(jv[jss::error] == "invalidParams");
+                BEAST_EXPECT(jv[jss::error_code] == RpcInvalidParams);
                 BEAST_EXPECT(jv[jss::error_message] == "Invalid parameters.");
             }
         });
@@ -185,6 +204,13 @@ public:
                     accountId(ammAlice, acct),
                     ignoreParams,
                     3);
+                BEAST_EXPECT(
+                    jv[jss::error] ==
+                    (acct == TestAccount::Bogie ? std::string("actMalformed")
+                                                : std::string("invalidParams")));
+                BEAST_EXPECT(
+                    jv[jss::error_code] ==
+                    (acct == TestAccount::Bogie ? RpcActMalformed : RpcInvalidParams));
                 BEAST_EXPECT(
                     jv[jss::error_message] ==
                     (acct == TestAccount::Bogie ? std::string("Account malformed.")
@@ -383,7 +409,9 @@ public:
         testAMM([&](AMM& amm, Env&) {
             auto const resp = amm.ammRpcInfo(
                 std::nullopt, jss::validated.cStr(), std::nullopt, std::nullopt, gw_);
-            BEAST_EXPECT(resp.isMember("error") && resp["error"] == "actNotFound");
+            BEAST_EXPECT(resp[jss::error] == "actNotFound");
+            BEAST_EXPECT(resp[jss::error_code] == RpcActNotFound);
+            BEAST_EXPECT(resp[jss::error_message] == "Account not found.");
         });
     }
 

src/test/rpc/AccountInfo_test.cpp

@@ -35,6 +35,7 @@ public:
         {
             // account_info with no account.
             auto const info = env.rpc("json", "account_info", "{ }");
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidParams");
             BEAST_EXPECT(info[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(info[jss::result][jss::error_message] == "Missing field 'account'.");
         }
@@ -45,6 +46,7 @@ public:
                 "account_info",
                 "{\"account\": "
                 "\"n94JNrQYkDrpt62bbSR7nVEhdyAvcJXRAsjEkFYyqRkh9SUTYEqV\"}");
+            BEAST_EXPECT(info[jss::result][jss::error] == "actMalformed");
             BEAST_EXPECT(info[jss::result][jss::error_code] == RpcActMalformed);
             BEAST_EXPECT(info[jss::result][jss::error_message] == "Account malformed.");
             BEAST_EXPECT(info[jss::result].isMember(jss::ledger_current_index));
@@ -56,6 +58,7 @@ public:
             json::Value params;
             params[jss::account] = bogie.human();
             auto const info = env.rpc("json", "account_info", to_string(params));
+            BEAST_EXPECT(info[jss::result][jss::error] == "actNotFound");
             BEAST_EXPECT(info[jss::result][jss::error_code] == RpcActNotFound);
             BEAST_EXPECT(info[jss::result][jss::error_message] == "Account not found.");
             BEAST_EXPECT(info[jss::result][jss::account] == bogie.human());
@@ -65,6 +68,7 @@ public:
         {
             // Cannot use a seed as account
             auto const info = env.rpc("json", "account_info", R"JSON({"account": "foo"})JSON");
+            BEAST_EXPECT(info[jss::result][jss::error] == "actMalformed");
             BEAST_EXPECT(info[jss::result][jss::error_code] == RpcActMalformed);
             BEAST_EXPECT(info[jss::result][jss::error_message] == "Account malformed.");
         }
@@ -334,6 +338,7 @@ public:
             BEAST_EXPECT(info[jss::status] == "error");
             BEAST_EXPECT(info[jss::error] == "invalidParams");
             BEAST_EXPECT(info[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(info[jss::error_message] == "Invalid parameters.");
             BEAST_EXPECT(info.isMember(jss::account_data));
             BEAST_EXPECT(info[jss::account_data][sfAccount.jsonName] == alice.human());
             BEAST_EXPECT(info.isMember(jss::ledger_current_index));

src/test/rpc/AccountLines_test.cpp

@@ -55,6 +55,7 @@ public:
         {
             // account_lines with no account.
             auto const lines = env.rpc("json", "account_lines", "{ }");
+            BEAST_EXPECT(lines[jss::result][jss::error] == "invalidParams");
             BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 lines[jss::result][jss::error_message] ==
@@ -65,6 +66,7 @@ public:
             json::Value params;
             params[jss::account] = "n9MJkEKHDhy5eTLuHUQeAAjo382frHNbFK4C8hcwN4nwM2SrLdBj";
             auto const lines = env.rpc("json", "account_lines", to_string(params));
+            BEAST_EXPECT(lines[jss::result][jss::error] == "actMalformed");
             BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcActMalformed);
             BEAST_EXPECT(
                 lines[jss::result][jss::error_message] ==
@@ -118,6 +120,7 @@ public:
             json::Value params;
             params[jss::account] = alice.human();
             auto const lines = env.rpc("json", "account_lines", to_string(params));
+            BEAST_EXPECT(lines[jss::result][jss::error] == "actNotFound");
             BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcActNotFound);
             BEAST_EXPECT(
                 lines[jss::result][jss::error_message] ==
@@ -161,6 +164,7 @@ public:
             params[jss::account] = alice.human();
             params[jss::ledger_index] = "nonsense";
             auto const lines = env.rpc("json", "account_lines", to_string(params));
+            BEAST_EXPECT(lines[jss::result][jss::error] == "invalidParams");
             BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 lines[jss::result][jss::error_message] ==
@@ -172,6 +176,7 @@ public:
             params[jss::account] = alice.human();
             params[jss::ledger_index] = 50000;
             auto const lines = env.rpc("json", "account_lines", to_string(params));
+            BEAST_EXPECT(lines[jss::result][jss::error] == "lgrNotFound");
             BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcLgrNotFound);
             BEAST_EXPECT(lines[jss::result][jss::error_message] == "ledgerNotFound");
         }
@@ -305,6 +310,7 @@ public:
             params[jss::account] = alice.human();
             params[jss::peer] = "n9MJkEKHDhy5eTLuHUQeAAjo382frHNbFK4C8hcwN4nwM2SrLdBj";
             auto const lines = env.rpc("json", "account_lines", to_string(params));
+            BEAST_EXPECT(lines[jss::result][jss::error] == "actMalformed");
             BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcActMalformed);
             BEAST_EXPECT(
                 lines[jss::result][jss::error_message] ==
@@ -344,6 +350,7 @@ public:
             params[jss::account] = alice.human();
             params[jss::limit] = -1;
             auto const lines = env.rpc("json", "account_lines", to_string(params));
+            BEAST_EXPECT(lines[jss::result][jss::error] == "invalidParams");
             BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 lines[jss::result][jss::error_message] ==
@@ -382,6 +389,7 @@ public:
             paramsD[jss::account] = alice.human();
             paramsD[jss::marker] = marker;
             auto const linesD = env.rpc("json", "account_lines", to_string(paramsD));
+            BEAST_EXPECT(linesD[jss::result][jss::error] == "invalidParams");
             BEAST_EXPECT(linesD[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 linesD[jss::result][jss::error_message] ==
@@ -393,6 +401,7 @@ public:
             params[jss::account] = alice.human();
             params[jss::marker] = true;
             auto const lines = env.rpc("json", "account_lines", to_string(params));
+            BEAST_EXPECT(lines[jss::result][jss::error] == "invalidParams");
             BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 lines[jss::result][jss::error_message] ==
@@ -404,6 +413,7 @@ public:
             params[jss::account] = alice.human();
             params[jss::marker] = "NOT_A_MARKER";
             auto const lines = env.rpc("json", "account_lines", to_string(params));
+            BEAST_EXPECT(lines[jss::result][jss::error] == "invalidParams");
             BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 lines[jss::result][jss::error_message] ==
@@ -548,7 +558,11 @@ public:
         beckyLinesParams[jss::account] = becky.human();
         beckyLinesParams[jss::marker] = aliceMarker;
         auto const beckyLines = env.rpc("json", "account_lines", to_string(beckyLinesParams));
-        BEAST_EXPECT(beckyLines[jss::result].isMember(jss::error_message));
+        BEAST_EXPECT(beckyLines[jss::result][jss::error] == "invalidParams");
+        BEAST_EXPECT(beckyLines[jss::result][jss::error_code] == RpcInvalidParams);
+        BEAST_EXPECT(
+            beckyLines[jss::result][jss::error_message] ==
+            rpc::makeError(RpcInvalidParams)[jss::error_message]);
     }
 
     void
@@ -616,6 +630,7 @@ public:
         linesEndParams[jss::account] = alice.human();
         linesEndParams[jss::marker] = linesBeg[jss::result][jss::marker];
         auto const linesEnd = env.rpc("json", "account_lines", to_string(linesEndParams));
+        BEAST_EXPECT(linesEnd[jss::result][jss::error] == "invalidParams");
         BEAST_EXPECT(linesEnd[jss::result][jss::error_code] == RpcInvalidParams);
         BEAST_EXPECT(
             linesEnd[jss::result][jss::error_message] ==
@@ -914,6 +929,7 @@ public:
             request[jss::ripplerpc] = "2.0";
             request[jss::id] = 5;
             auto const lines = env.rpc("json2", to_string(request));
+            BEAST_EXPECT(lines[jss::error][jss::error] == "invalidParams");
             BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 lines[jss::error][jss::message] ==
@@ -933,6 +949,7 @@ public:
             request[jss::id] = 5;
             request[jss::params] = params;
             auto const lines = env.rpc("json2", to_string(request));
+            BEAST_EXPECT(lines[jss::error][jss::error] == "actMalformed");
             BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcActMalformed);
             BEAST_EXPECT(
                 lines[jss::error][jss::message] ==
@@ -953,6 +970,7 @@ public:
             request[jss::id] = 5;
             request[jss::params] = params;
             auto const lines = env.rpc("json2", to_string(request));
+            BEAST_EXPECT(lines[jss::error][jss::error] == "actNotFound");
             BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcActNotFound);
             BEAST_EXPECT(
                 lines[jss::error][jss::message] ==
@@ -1025,6 +1043,7 @@ public:
             request[jss::id] = 5;
             request[jss::params] = params;
             auto const lines = env.rpc("json2", to_string(request));
+            BEAST_EXPECT(lines[jss::error][jss::error] == "invalidParams");
             BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 lines[jss::error][jss::message] ==
@@ -1045,6 +1064,7 @@ public:
             request[jss::id] = 5;
             request[jss::params] = params;
             auto const lines = env.rpc("json2", to_string(request));
+            BEAST_EXPECT(lines[jss::error][jss::error] == "lgrNotFound");
             BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcLgrNotFound);
             BEAST_EXPECT(lines[jss::error][jss::message] == "ledgerNotFound");
             BEAST_EXPECT(lines.isMember(jss::jsonrpc) && lines[jss::jsonrpc] == "2.0");
@@ -1220,6 +1240,7 @@ public:
             request[jss::id] = 5;
             request[jss::params] = params;
             auto const lines = env.rpc("json2", to_string(request));
+            BEAST_EXPECT(lines[jss::error][jss::error] == "actMalformed");
             BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcActMalformed);
             BEAST_EXPECT(
                 lines[jss::error][jss::message] ==
@@ -1240,6 +1261,7 @@ public:
             request[jss::id] = 5;
             request[jss::params] = params;
             auto const lines = env.rpc("json2", to_string(request));
+            BEAST_EXPECT(lines[jss::error][jss::error] == "invalidParams");
             BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 lines[jss::error][jss::message] ==
@@ -1314,6 +1336,7 @@ public:
             requestD[jss::id] = 5;
             requestD[jss::params] = paramsD;
             auto const linesD = env.rpc("json2", to_string(requestD));
+            BEAST_EXPECT(linesD[jss::error][jss::error] == "invalidParams");
             BEAST_EXPECT(linesD[jss::error][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 linesD[jss::error][jss::message] ==
@@ -1334,6 +1357,7 @@ public:
             request[jss::id] = 5;
             request[jss::params] = params;
             auto const lines = env.rpc("json2", to_string(request));
+            BEAST_EXPECT(lines[jss::error][jss::error] == "invalidParams");
             BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 lines[jss::error][jss::message] ==
@@ -1492,6 +1516,7 @@ public:
         linesEndRequest[jss::id] = 5;
         linesEndRequest[jss::params] = linesEndParams;
         auto const linesEnd = env.rpc("json2", to_string(linesEndRequest));
+        BEAST_EXPECT(linesEnd[jss::error][jss::error] == "invalidParams");
         BEAST_EXPECT(linesEnd[jss::error][jss::error_code] == RpcInvalidParams);
         BEAST_EXPECT(
             linesEnd[jss::error][jss::message] ==

src/test/rpc/AccountObjects_test.cpp

@@ -140,6 +140,8 @@ public:
         {
             json::Value const params;
             auto resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Missing field 'account'.");
         }
         // test account non-string
@@ -149,6 +151,7 @@ public:
                 params[jss::account] = param;
                 auto jrr = env.rpc("json", "account_objects", to_string(params))[jss::result];
                 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+                BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
                 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'account'.");
             };
 
@@ -164,6 +167,8 @@ public:
             json::Value params;
             params[jss::account] = "n94JNrQYkDrpt62bbSR7nVEhdyAvcJXRAsjEkFYyqRkh9SUTYEqV";
             auto resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "actMalformed");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcActMalformed);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Account malformed.");
         }
         // test error on account that's not in the ledger.
@@ -171,6 +176,8 @@ public:
             json::Value params;
             params[jss::account] = Account{"bogie"}.human();
             auto resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "actNotFound");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcActNotFound);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Account not found.");
         }
         Account const bob{"bob"};
@@ -180,6 +187,8 @@ public:
             params[jss::account] = bob.human();
             params[jss::ledger_index] = 10;
             auto resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "lgrNotFound");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcLgrNotFound);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "ledgerNotFound");
         }
 
@@ -190,6 +199,8 @@ public:
             params[jss::account] = bob.human();
             params[jss::type] = 10;
             auto resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] == "Invalid field 'type', not string.");
         }
@@ -199,6 +210,8 @@ public:
             params[jss::account] = bob.human();
             params[jss::type] = "expedited";
             auto resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'type'.");
         }
         // test error on limit -ve
@@ -207,6 +220,8 @@ public:
             params[jss::account] = bob.human();
             params[jss::limit] = -1;
             auto resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] ==
                 "Invalid field 'limit', not unsigned integer.");
@@ -217,6 +232,8 @@ public:
             params[jss::account] = bob.human();
             params[jss::sponsored] = "true";
             auto resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] == "Invalid field 'sponsored', not boolean.");
         }
@@ -238,27 +255,39 @@ public:
             std::string mark = to_string(resumeMarker);
             params[jss::marker] = 10;
             resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] == "Invalid field 'marker', not string.");
 
             params[jss::marker] = "This is a string with no comma";
             resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'marker'.");
 
             params[jss::marker] = "This string has a comma, but is not hex";
             resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'marker'.");
 
             params[jss::marker] = std::string(&mark[1U], 64);
             resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'marker'.");
 
             params[jss::marker] = std::string(&mark[1U], 65);
             resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'marker'.");
 
             params[jss::marker] = std::string(&mark[1U], 65) + "not hex";
             resp = env.rpc("json", "account_objects", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'marker'.");
 
             // Should this be an error?
@@ -603,7 +632,8 @@ public:
 
         // Make a lambda that checks if the response has error for invalid type
         auto const acctObjsTypeIsInvalid = [](json::Value const& resp) {
-            return resp[jss::result].isMember(jss::error) &&
+            return resp[jss::result][jss::error] == "invalidParams" &&
+                resp[jss::result][jss::error_code] == RpcInvalidParams &&
                 resp[jss::result][jss::error_message] == "Invalid field \'type\'.";
         };
 
@@ -1174,7 +1204,9 @@ public:
             params[jss::ledger_index] = jss::validated;
             params[jss::marker] = marker;
             json::Value const resp = env.rpc("json", "account_nfts", to_string(params));
-            return resp[jss::result][jss::error_message] == errorMessage;
+            return resp[jss::result][jss::error] == "invalidParams" &&
+                resp[jss::result][jss::error_code] == RpcInvalidParams &&
+                resp[jss::result][jss::error_message] == errorMessage;
         };
 
         // test an invalid marker that is not a string
@@ -1427,7 +1459,9 @@ public:
             params[jss::ledger_index] = jss::validated;
             params[jss::marker] = marker;
             json::Value const resp = env.rpc("json", "account_objects", to_string(params));
-            return resp[jss::result][jss::error_message] == "Invalid field \'marker\'.";
+            return resp[jss::result][jss::error] == "invalidParams" &&
+                resp[jss::result][jss::error_code] == RpcInvalidParams &&
+                resp[jss::result][jss::error_message] == "Invalid field \'marker\'.";
         };
 
         auto const markerStr = marker.asString();

src/test/rpc/AccountOffers_test.cpp

@@ -173,7 +173,9 @@ public:
             jvParams[jss::limit] = 0u;
             auto const jrr =
                 env.rpc("json", "account_offers", jvParams.toStyledString())[jss::result];
-            BEAST_EXPECT(jrr.isMember(jss::error_message));
+            BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'limit'.");
         }
     }
 
@@ -195,9 +197,9 @@ public:
         {
             // no account field
             auto const jrr = env.rpc("account_offers");
+            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "badSyntax");
             BEAST_EXPECT(jrr[jss::error_code] == RpcBadSyntax);
-            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error_message] == "Syntax error.");
         }
 
@@ -226,9 +228,9 @@ public:
             jvParams[jss::account] = "";
             auto const jrr =
                 env.rpc("json", "account_offers", jvParams.toStyledString())[jss::result];
+            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "actMalformed");
             BEAST_EXPECT(jrr[jss::error_code] == RpcActMalformed);
-            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error_message] == "Account malformed.");
             BEAST_EXPECT(jrr.isMember(jss::ledger_current_index));
             BEAST_EXPECT(jrr[jss::validated] == false);
@@ -237,9 +239,9 @@ public:
         {
             // bogus account value
             auto const jrr = env.rpc("account_offers", Account("bogus").human())[jss::result];
+            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "actNotFound");
             BEAST_EXPECT(jrr[jss::error_code] == RpcActNotFound);
-            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error_message] == "Account not found.");
         }
 
@@ -250,9 +252,9 @@ public:
             jvParams[jss::limit] = "0";  // NOT an integer
             auto const jrr =
                 env.rpc("json", "account_offers", jvParams.toStyledString())[jss::result];
+            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
             BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
-            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'limit', not unsigned integer.");
         }
 
@@ -263,9 +265,9 @@ public:
             jvParams[jss::marker] = "NOT_A_MARKER";
             auto const jrr =
                 env.rpc("json", "account_offers", jvParams.toStyledString())[jss::result];
+            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
             BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
-            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECTS(
                 jrr[jss::error_message] == "Invalid field 'marker'.", jrr.toStyledString());
         }
@@ -277,9 +279,9 @@ public:
             jvParams[jss::marker] = 1;
             auto const jrr =
                 env.rpc("json", "account_offers", jvParams.toStyledString())[jss::result];
+            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
             BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
-            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'marker', not string.");
         }
 
@@ -290,9 +292,9 @@ public:
             jvParams[jss::ledger_index] = 10u;
             auto const jrr =
                 env.rpc("json", "account_offers", jvParams.toStyledString())[jss::result];
+            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error] == "lgrNotFound");
             BEAST_EXPECT(jrr[jss::error_code] == RpcLgrNotFound);
-            BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error_message] == "ledgerNotFound");
         }
 

src/test/rpc/AccountTx_test.cpp

@@ -195,19 +195,27 @@ class AccountTx_test : public beast::unit_test::Suite
                 (j[jss::result][jss::transactions].size() == 0);
         };
 
-        auto const isErr = [](json::Value const& j, ErrorCodeI code) {
-            return j.isMember(jss::result) && j[jss::result].isMember(jss::error) &&
-                j[jss::result][jss::error] == rpc::getErrorInfo(code).token;
+        auto const isErr = [](json::Value const& j, ErrorCodeI code, std::string const& message) {
+            return j.isMember(jss::result) &&
+                j[jss::result][jss::error] == rpc::getErrorInfo(code).token &&
+                j[jss::result][jss::error_code] == code &&
+                j[jss::result][jss::error_message] == message;
         };
 
         json::Value jParams;
         jParams[jss::api_version] = apiVersion;
 
-        BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(jParams)), RpcInvalidParams));
+        BEAST_EXPECT(isErr(
+            env.rpc("json", "account_tx", to_string(jParams)),
+            RpcInvalidParams,
+            "Missing field 'account'."));
 
         jParams[jss::account] = "0xDEADBEEF";
 
-        BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(jParams)), RpcActMalformed));
+        BEAST_EXPECT(isErr(
+            env.rpc("json", "account_tx", to_string(jParams)),
+            RpcActMalformed,
+            "Account malformed."));
 
         jParams[jss::account] = a1.human();
         BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(jParams))));
@@ -227,8 +235,10 @@ class AccountTx_test : public beast::unit_test::Suite
             }
             else
             {
-                BEAST_EXPECT(
-                    isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrIdxMalformed));
+                BEAST_EXPECT(isErr(
+                    env.rpc("json", "account_tx", to_string(p)),
+                    RpcLgrIdxMalformed,
+                    "Ledger index malformed."));
             }
 
             p[jss::ledger_index_min] = 1;
@@ -239,15 +249,18 @@ class AccountTx_test : public beast::unit_test::Suite
             }
             else
             {
-                BEAST_EXPECT(
-                    isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrIdxMalformed));
+                BEAST_EXPECT(isErr(
+                    env.rpc("json", "account_tx", to_string(p)),
+                    RpcLgrIdxMalformed,
+                    "Ledger index malformed."));
             }
 
             p[jss::ledger_index_min] = 2;
             p[jss::ledger_index_max] = 1;
             BEAST_EXPECT(isErr(
                 env.rpc("json", "account_tx", to_string(p)),
-                (apiVersion == 1 ? RpcLgrIdxsInvalid : RpcInvalidLgrRange)));
+                (apiVersion == 1 ? RpcLgrIdxsInvalid : RpcInvalidLgrRange),
+                (apiVersion == 1 ? "Ledger indexes invalid." : "Ledger range is invalid.")));
         }
         // Ledger index min only
         {
@@ -262,14 +275,17 @@ class AccountTx_test : public beast::unit_test::Suite
             }
             else
             {
-                BEAST_EXPECT(
-                    isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrIdxMalformed));
+                BEAST_EXPECT(isErr(
+                    env.rpc("json", "account_tx", to_string(p)),
+                    RpcLgrIdxMalformed,
+                    "Ledger index malformed."));
             }
 
             p[jss::ledger_index_min] = env.current()->header().seq;
             BEAST_EXPECT(isErr(
                 env.rpc("json", "account_tx", to_string(p)),
-                (apiVersion == 1 ? RpcLgrIdxsInvalid : RpcInvalidLgrRange)));
+                (apiVersion == 1 ? RpcLgrIdxsInvalid : RpcInvalidLgrRange),
+                (apiVersion == 1 ? "Ledger indexes invalid." : "Ledger range is invalid.")));
         }
 
         // Ledger index max only
@@ -285,8 +301,10 @@ class AccountTx_test : public beast::unit_test::Suite
             }
             else
             {
-                BEAST_EXPECT(
-                    isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrIdxMalformed));
+                BEAST_EXPECT(isErr(
+                    env.rpc("json", "account_tx", to_string(p)),
+                    RpcLgrIdxMalformed,
+                    "Ledger index malformed."));
             }
 
             p[jss::ledger_index_max] = 3;
@@ -310,10 +328,14 @@ class AccountTx_test : public beast::unit_test::Suite
             BEAST_EXPECT(noTxs(env.rpc("json", "account_tx", to_string(p))));
 
             p[jss::ledger_index] = env.current()->header().seq;
-            BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrNotValidated));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcLgrNotValidated,
+                "Ledger not validated."));
 
             p[jss::ledger_index] = env.current()->header().seq + 1;
-            BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrNotFound));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)), RpcLgrNotFound, "ledgerNotFound"));
         }
 
         {
@@ -326,10 +348,16 @@ class AccountTx_test : public beast::unit_test::Suite
             BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
 
             p[jss::ledger_index] = "current";
-            BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrNotValidated));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcLgrNotValidated,
+                "Ledger not validated."));
 
             p[jss::ledger_index] = "";
-            BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrNotValidated));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcLgrNotValidated,
+                "Ledger not validated."));
         }
 
         // Ledger Hash
@@ -360,7 +388,10 @@ class AccountTx_test : public beast::unit_test::Suite
             }
             else
             {
-                BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcInvalidParams));
+                BEAST_EXPECT(isErr(
+                    env.rpc("json", "account_tx", to_string(p)),
+                    RpcInvalidParams,
+                    "invalidParams"));
             }
         }
 
@@ -374,8 +405,10 @@ class AccountTx_test : public beast::unit_test::Suite
             }
             else
             {
-                BEAST_EXPECT(
-                    isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrIdxMalformed));
+                BEAST_EXPECT(isErr(
+                    env.rpc("json", "account_tx", to_string(p)),
+                    RpcLgrIdxMalformed,
+                    "Ledger index malformed."));
             }
         }
         // test account non-string
@@ -385,6 +418,7 @@ class AccountTx_test : public beast::unit_test::Suite
                 params[jss::account] = param;
                 auto jrr = env.rpc("json", "account_tx", to_string(params))[jss::result];
                 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+                BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
                 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'account'.");
             };
 
@@ -406,7 +440,10 @@ class AccountTx_test : public beast::unit_test::Suite
             }
             else
             {
-                BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcInvalidParams));
+                BEAST_EXPECT(isErr(
+                    env.rpc("json", "account_tx", to_string(p)),
+                    RpcInvalidParams,
+                    "Invalid field 'binary'."));
             }
 
             p[jss::binary] = true;
@@ -420,7 +457,10 @@ class AccountTx_test : public beast::unit_test::Suite
             }
             else
             {
-                BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcInvalidParams));
+                BEAST_EXPECT(isErr(
+                    env.rpc("json", "account_tx", to_string(p)),
+                    RpcInvalidParams,
+                    "Invalid field 'forward'."));
             }
 
             p[jss::forward] = false;
@@ -433,70 +473,83 @@ class AccountTx_test : public beast::unit_test::Suite
 
             // Test case: limit = 0 should fail (below minimum)
             p[jss::limit] = 0;
-            BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcInvalidParams));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcInvalidParams,
+                "Invalid field 'limit'."));
 
             // Test case: limit = 1.2 should fail (not an integer)
             p[jss::limit] = 1.2;
-            BEAST_EXPECT(
-                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
-                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcInvalidParams,
+                rpc::expectedFieldMessage(jss::limit, "unsigned integer")));
 
             // Test case: limit = "10" should fail (string instead of integer)
             p[jss::limit] = "10";
-            BEAST_EXPECT(
-                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
-                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcInvalidParams,
+                rpc::expectedFieldMessage(jss::limit, "unsigned integer")));
 
             // Test case: limit = true should fail (boolean instead of integer)
             p[jss::limit] = true;
-            BEAST_EXPECT(
-                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
-                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcInvalidParams,
+                rpc::expectedFieldMessage(jss::limit, "unsigned integer")));
 
             // Test case: limit = false should fail (boolean instead of integer)
             p[jss::limit] = false;
-            BEAST_EXPECT(
-                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
-                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcInvalidParams,
+                rpc::expectedFieldMessage(jss::limit, "unsigned integer")));
 
             // Test case: limit = -1 should fail (negative number)
             p[jss::limit] = -1;
-            BEAST_EXPECT(
-                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
-                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcInvalidParams,
+                rpc::expectedFieldMessage(jss::limit, "unsigned integer")));
 
             // Test case: limit = [] should fail (array instead of integer)
             p[jss::limit] = json::Value(json::ValueType::Array);
-            BEAST_EXPECT(
-                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
-                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcInvalidParams,
+                rpc::expectedFieldMessage(jss::limit, "unsigned integer")));
 
             // Test case: limit = {} should fail (object instead of integer)
             p[jss::limit] = json::Value(json::ValueType::Object);
-            BEAST_EXPECT(
-                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
-                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcInvalidParams,
+                rpc::expectedFieldMessage(jss::limit, "unsigned integer")));
 
             // Test case: limit = "malformed" should fail (malformed string)
             p[jss::limit] = "malformed";
-            BEAST_EXPECT(
-                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
-                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcInvalidParams,
+                rpc::expectedFieldMessage(jss::limit, "unsigned integer")));
 
             // Test case: limit = ["limit"] should fail (array with string)
             p[jss::limit] = json::Value(json::ValueType::Array);
             p[jss::limit].append("limit");
-            BEAST_EXPECT(
-                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
-                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcInvalidParams,
+                rpc::expectedFieldMessage(jss::limit, "unsigned integer")));
 
             // Test case: limit = {"limit": 10} should fail (object with
             // property)
             p[jss::limit] = json::Value(json::ValueType::Object);
             p[jss::limit][jss::limit] = 10;
-            BEAST_EXPECT(
-                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
-                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
+            BEAST_EXPECT(isErr(
+                env.rpc("json", "account_tx", to_string(p)),
+                RpcInvalidParams,
+                rpc::expectedFieldMessage(jss::limit, "unsigned integer")));
 
             // Test case: limit = 10 should succeed (valid integer)
             p[jss::limit] = 10;
@@ -985,12 +1038,16 @@ class AccountTx_test : public beast::unit_test::Suite
         };
 
         auto const checkError = [&](json::Value const& delegateParams,
-                                    std::string const& errToken) {
+                                    std::string const& errToken,
+                                    ErrorCodeI code,
+                                    std::string const& errMessage) {
             json::Value params;
             params[jss::account] = alice.human();
             params[jss::delegate] = delegateParams;
             auto res = env.rpc("json", "account_tx", to_string(params));
             BEAST_EXPECT(res[jss::result][jss::error] == errToken);
+            BEAST_EXPECT(res[jss::result][jss::error_code] == code);
+            BEAST_EXPECT(res[jss::result][jss::error_message] == errMessage);
         };
 
         // Filter: Delegatee. Expects TX #2 (Signed by Bob)
@@ -1061,27 +1118,27 @@ class AccountTx_test : public beast::unit_test::Suite
         // "delegate" is not an object (e.g., string)
         {
             json::Value const p = "not_an_object";
-            checkError(p, "invalidParams");
+            checkError(p, "invalidParams", RpcInvalidParams, "Invalid field 'delegate'.");
         }
 
         // Missing "delegate_filter" inside object
         {
             json::Value const p(json::ValueType::Object);
-            checkError(p, "invalidParams");
+            checkError(p, "invalidParams", RpcInvalidParams, "Invalid field 'delegate_filter'.");
         }
 
         // "delegate_filter" is not a string (e.g., int)
         {
             json::Value p;
             p[jss::delegate_filter] = 123;
-            checkError(p, "invalidParams");
+            checkError(p, "invalidParams", RpcInvalidParams, "Invalid field 'delegate_filter'.");
         }
 
         // "delegate_filter" has invalid value
         {
             json::Value p;
             p[jss::delegate_filter] = "random_string";
-            checkError(p, "invalidParams");
+            checkError(p, "invalidParams", RpcInvalidParams, "Invalid field 'delegate_filter'.");
         }
 
         // "counterparty" is not a string
@@ -1089,7 +1146,7 @@ class AccountTx_test : public beast::unit_test::Suite
             json::Value p;
             p[jss::delegate_filter] = "actor";
             p[jss::counter_party] = 123;
-            checkError(p, "invalidParams");
+            checkError(p, "invalidParams", RpcInvalidParams, "Invalid field 'counter_party'.");
         }
 
         // "counterparty" is malformed base58
@@ -1097,7 +1154,7 @@ class AccountTx_test : public beast::unit_test::Suite
             json::Value p;
             p[jss::delegate_filter] = "actor";
             p[jss::counter_party] = "not_an_account";
-            checkError(p, "actMalformed");
+            checkError(p, "actMalformed", RpcActMalformed, "Account malformed.");
         }
 
         // Multi-signed non-delegated TX: Alice pays Carol via multi-sig.
@@ -1181,6 +1238,11 @@ class AccountTx_test : public beast::unit_test::Suite
                 p[jss::marker] = delegateMarker;
                 auto const r = env.rpc("json", "account_tx", to_string(p));
                 BEAST_EXPECT(r[jss::result][jss::error] == "invalidParams");
+                BEAST_EXPECT(r[jss::result][jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(
+                    r[jss::result][jss::error_message] ==
+                    "Do not mix delegate and non-delegate pagination markers in account_tx; "
+                    "repeat the same `delegate` object when using a delegate marker.");
             }
 
             // Obtain a non-delegate marker; it must not carry the flag.
@@ -1205,6 +1267,11 @@ class AccountTx_test : public beast::unit_test::Suite
                 p[jss::marker] = normalMarker;
                 auto const r = env.rpc("json", "account_tx", to_string(p));
                 BEAST_EXPECT(r[jss::result][jss::error] == "invalidParams");
+                BEAST_EXPECT(r[jss::result][jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(
+                    r[jss::result][jss::error_message] ==
+                    "Do not mix delegate and non-delegate pagination markers in account_tx; "
+                    "repeat the same `delegate` object when using a delegate marker.");
             }
         }
     }

src/test/rpc/AmendmentBlocked_test.cpp

@@ -14,6 +14,7 @@
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/config/Constants.h>
 #include <xrpl/json/to_string.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/KeyType.h>
 #include <xrpl/protocol/Serializer.h>
 #include <xrpl/protocol/jss.h>
@@ -186,32 +187,42 @@ class AmendmentBlocked_test : public beast::unit_test::Suite
 
         // ledger_accept
         jr = env.rpc("ledger_accept")[jss::result];
-        BEAST_EXPECT(jr.isMember(jss::error) && jr[jss::error] == "amendmentBlocked");
         BEAST_EXPECT(jr[jss::status] == "error");
+        BEAST_EXPECT(jr[jss::error] == "amendmentBlocked");
+        BEAST_EXPECT(jr[jss::error_code] == RpcAmendmentBlocked);
+        BEAST_EXPECT(jr[jss::error_message] == "Amendment blocked, need upgrade.");
         BEAST_EXPECT(!jr.isMember(jss::warnings));
 
         // ledger_current
         jr = env.rpc("ledger_current")[jss::result];
-        BEAST_EXPECT(jr.isMember(jss::error) && jr[jss::error] == "amendmentBlocked");
         BEAST_EXPECT(jr[jss::status] == "error");
+        BEAST_EXPECT(jr[jss::error] == "amendmentBlocked");
+        BEAST_EXPECT(jr[jss::error_code] == RpcAmendmentBlocked);
+        BEAST_EXPECT(jr[jss::error_message] == "Amendment blocked, need upgrade.");
         BEAST_EXPECT(!jr.isMember(jss::warnings));
 
         // owner_info
         jr = env.rpc("owner_info", alice.human())[jss::result];
-        BEAST_EXPECT(jr.isMember(jss::error) && jr[jss::error] == "amendmentBlocked");
         BEAST_EXPECT(jr[jss::status] == "error");
+        BEAST_EXPECT(jr[jss::error] == "amendmentBlocked");
+        BEAST_EXPECT(jr[jss::error_code] == RpcAmendmentBlocked);
+        BEAST_EXPECT(jr[jss::error_message] == "Amendment blocked, need upgrade.");
         BEAST_EXPECT(!jr.isMember(jss::warnings));
 
         // path_find
         jr = wsc->invoke("path_find", pfReq)[jss::result];
-        BEAST_EXPECT(jr.isMember(jss::error) && jr[jss::error] == "amendmentBlocked");
         BEAST_EXPECT(jr[jss::status] == "error");
+        BEAST_EXPECT(jr[jss::error] == "amendmentBlocked");
+        BEAST_EXPECT(jr[jss::error_code] == RpcAmendmentBlocked);
+        BEAST_EXPECT(jr[jss::error_message] == "Amendment blocked, need upgrade.");
         BEAST_EXPECT(!jr.isMember(jss::warnings));
 
         // submit
         jr = env.rpc("submit", strHex(s.slice()))[jss::result];
-        BEAST_EXPECT(jr.isMember(jss::error) && jr[jss::error] == "amendmentBlocked");
         BEAST_EXPECT(jr[jss::status] == "error");
+        BEAST_EXPECT(jr[jss::error] == "amendmentBlocked");
+        BEAST_EXPECT(jr[jss::error_code] == RpcAmendmentBlocked);
+        BEAST_EXPECT(jr[jss::error_message] == "Amendment blocked, need upgrade.");
         BEAST_EXPECT(!jr.isMember(jss::warnings));
 
         // submit_multisigned
@@ -221,7 +232,9 @@ class AmendmentBlocked_test : public beast::unit_test::Suite
         BEAST_EXPECT(jr[jss::status] == "success");
         msReq[jss::tx_json] = jr[jss::tx_json];
         jr = env.rpc("json", "submit_multisigned", to_string(msReq))[jss::result];
-        BEAST_EXPECT(jr.isMember(jss::error) && jr[jss::error] == "amendmentBlocked");
+        BEAST_EXPECT(jr[jss::error] == "amendmentBlocked");
+        BEAST_EXPECT(jr[jss::error_code] == RpcAmendmentBlocked);
+        BEAST_EXPECT(jr[jss::error_message] == "Amendment blocked, need upgrade.");
         BEAST_EXPECT(!jr.isMember(jss::warnings));
     }
 

src/test/rpc/BookChanges_test.cpp

@@ -19,6 +19,7 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
 #include <xrpl/ledger/Ledger.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/SField.h>
@@ -77,8 +78,12 @@ public:
         // non-conventional ledger input should throw an error
         params["ledger"] = "non_conventional_ledger_input";
         resp = env.rpc("json", "book_changes", to_string(params));
-        BEAST_EXPECT(resp[jss::result].isMember(jss::error));
-        BEAST_EXPECT(resp[jss::result][jss::status] != "success");
+        BEAST_EXPECT(resp[jss::result][jss::status] == "error");
+        BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+        BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
+        BEAST_EXPECT(
+            resp[jss::result][jss::error_message] ==
+            "Invalid field 'ledger', not string or number.");
     }
 
     void

src/test/rpc/Book_test.cpp

@@ -20,6 +20,7 @@
 #include <xrpl/json/to_string.h>
 #include <xrpl/ledger/helpers/DirectoryHelpers.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
@@ -1225,6 +1226,7 @@ public:
             jvParams[jss::ledger_index] = 10u;
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "lgrNotFound");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcLgrNotFound);
             BEAST_EXPECT(jrr[jss::error_message] == "ledgerNotFound");
         }
 
@@ -1233,6 +1235,7 @@ public:
             jvParams[jss::ledger_index] = "validated";
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Missing field 'taker_pays'.");
         }
 
@@ -1242,6 +1245,7 @@ public:
             jvParams[jss::taker_pays] = json::ValueType::Object;
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Missing field 'taker_gets'.");
         }
 
@@ -1252,6 +1256,7 @@ public:
             jvParams[jss::taker_gets] = json::ValueType::Object;
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'taker_pays', not object.");
         }
 
@@ -1262,6 +1267,7 @@ public:
             jvParams[jss::taker_gets] = "not an object";
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'taker_gets', not object.");
         }
 
@@ -1272,6 +1278,7 @@ public:
             jvParams[jss::taker_gets] = json::ValueType::Object;
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Missing field 'taker_pays.currency'.");
         }
 
@@ -1282,6 +1289,7 @@ public:
             jvParams[jss::taker_gets] = json::ValueType::Object;
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 jrr[jss::error_message] == "Invalid field 'taker_pays.currency', not string.");
         }
@@ -1293,6 +1301,7 @@ public:
             jvParams[jss::taker_gets] = json::ValueType::Object;
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Missing field 'taker_gets.currency'.");
         }
 
@@ -1303,6 +1312,7 @@ public:
             jvParams[jss::taker_gets][jss::currency] = 1;
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 jrr[jss::error_message] == "Invalid field 'taker_gets.currency', not string.");
         }
@@ -1314,6 +1324,7 @@ public:
             jvParams[jss::taker_gets][jss::currency] = "XRP";
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "srcCurMalformed");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcSrcCurMalformed);
             BEAST_EXPECT(
                 jrr[jss::error_message] == "Invalid field 'taker_pays.currency', bad currency.");
         }
@@ -1325,6 +1336,7 @@ public:
             jvParams[jss::taker_gets][jss::currency] = "NOT_VALID";
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "dstAmtMalformed");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcDstAmtMalformed);
             BEAST_EXPECT(
                 jrr[jss::error_message] == "Invalid field 'taker_gets.currency', bad currency.");
         }
@@ -1337,6 +1349,7 @@ public:
             jvParams[jss::taker_gets][jss::issuer] = 1;
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 jrr[jss::error_message] == "Invalid field 'taker_gets.issuer', not string.");
         }
@@ -1349,6 +1362,7 @@ public:
             jvParams[jss::taker_gets][jss::currency] = "USD";
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 jrr[jss::error_message] == "Invalid field 'taker_pays.issuer', not string.");
         }
@@ -1361,6 +1375,7 @@ public:
             jvParams[jss::taker_gets][jss::currency] = "USD";
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "srcIsrMalformed");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcSrcIsrMalformed);
             BEAST_EXPECT(
                 jrr[jss::error_message] == "Invalid field 'taker_pays.issuer', bad issuer.");
         }
@@ -1373,6 +1388,7 @@ public:
             jvParams[jss::taker_gets][jss::currency] = "USD";
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "srcIsrMalformed");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcSrcIsrMalformed);
             BEAST_EXPECT(
                 jrr[jss::error_message] ==
                 "Invalid field 'taker_pays.issuer', bad issuer account one.");
@@ -1386,6 +1402,7 @@ public:
             jvParams[jss::taker_gets][jss::issuer] = gw.human() + "DEAD";
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "dstIsrMalformed");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcDstIsrMalformed);
             BEAST_EXPECT(
                 jrr[jss::error_message] == "Invalid field 'taker_gets.issuer', bad issuer.");
         }
@@ -1398,6 +1415,7 @@ public:
             jvParams[jss::taker_gets][jss::issuer] = toBase58(noAccount());
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "dstIsrMalformed");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcDstIsrMalformed);
             BEAST_EXPECT(
                 jrr[jss::error_message] ==
                 "Invalid field 'taker_gets.issuer', bad issuer account one.");
@@ -1412,6 +1430,7 @@ public:
             jvParams[jss::taker_gets][jss::issuer] = gw.human();
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "srcIsrMalformed");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcSrcIsrMalformed);
             BEAST_EXPECT(
                 jrr[jss::error_message] ==
                 "Unneeded field 'taker_pays.issuer' "
@@ -1427,6 +1446,7 @@ public:
             jvParams[jss::taker_gets][jss::issuer] = gw.human();
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "srcIsrMalformed");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcSrcIsrMalformed);
             BEAST_EXPECT(
                 jrr[jss::error_message] ==
                 "Invalid field 'taker_pays.issuer', expected non-XRP issuer.");
@@ -1441,6 +1461,7 @@ public:
             jvParams[jss::taker_gets][jss::issuer] = gw.human();
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'taker', not string.");
         }
 
@@ -1453,6 +1474,7 @@ public:
             jvParams[jss::taker_gets][jss::issuer] = gw.human();
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'taker'.");
         }
 
@@ -1466,6 +1488,7 @@ public:
             jvParams[jss::taker_gets][jss::issuer] = gw.human();
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "badMarket");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcBadMarket);
             BEAST_EXPECT(jrr[jss::error_message] == "No such market.");
         }
 
@@ -1479,6 +1502,7 @@ public:
             jvParams[jss::taker_gets][jss::issuer] = gw.human();
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'limit', not unsigned integer.");
         }
 
@@ -1492,6 +1516,7 @@ public:
             jvParams[jss::taker_gets][jss::issuer] = gw.human();
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'limit'.");
         }
 
@@ -1503,6 +1528,7 @@ public:
             jvParams[jss::taker_gets][jss::currency] = "USD";
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "dstIsrMalformed");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcDstIsrMalformed);
             BEAST_EXPECT(
                 jrr[jss::error_message] ==
                 "Invalid field 'taker_gets.issuer', "
@@ -1518,6 +1544,7 @@ public:
             jvParams[jss::taker_gets][jss::issuer] = gw.human();
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "dstIsrMalformed");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcDstIsrMalformed);
             BEAST_EXPECT(
                 jrr[jss::error_message] ==
                 "Unneeded field 'taker_gets.issuer' "
@@ -1533,6 +1560,7 @@ public:
             jvParams[jss::domain] = "badString";
             auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "domainMalformed");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcDomainMalformed);
             BEAST_EXPECT(jrr[jss::error_message] == "Unable to parse domain.");
         }
     }

src/test/rpc/Connect_test.cpp

@@ -2,6 +2,7 @@
 #include <test/jtx/Env.h>
 
 #include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/jss.h>
 
 namespace xrpl {
@@ -22,8 +23,8 @@ class Connect_test : public beast::unit_test::Suite
 
             auto const result = env.rpc("json", "connect", "{}");
             BEAST_EXPECT(result[jss::result][jss::status] == "error");
-            BEAST_EXPECT(result[jss::result].isMember(jss::error));
             BEAST_EXPECT(result[jss::result][jss::error] == "notSynced");
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcNotSynced);
             BEAST_EXPECT(result[jss::result][jss::error_message] == "Not synced to the network.");
         }
     }

src/test/rpc/DepositAuthorized_test.cpp

@@ -8,6 +8,7 @@
 
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_value.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Protocol.h>  // IWYU pragma: keep
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/TxFlags.h>
@@ -154,12 +155,16 @@ public:
         Account const becky{"becky"};
 
         // Lambda that checks the (error) result of deposit_authorized.
-        auto const verifyErr =
-            [this](json::Value const& result, char const* error, char const* errorMsg) {
-                BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
-                BEAST_EXPECT(result[jss::result][jss::error] == error);
-                BEAST_EXPECT(result[jss::result][jss::error_message] == errorMsg);
-            };
+        auto const verifyErr = [this](
+                                   json::Value const& result,
+                                   char const* error,
+                                   ErrorCodeI code,
+                                   char const* errorMsg) {
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == error);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == code);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == errorMsg);
+        };
 
         Env env(*this);
         {
@@ -167,28 +172,33 @@ public:
             json::Value args{depositAuthArgs(alice, becky)};
             args.removeMember(jss::source_account);
             json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
-            verifyErr(result, "invalidParams", "Missing field 'source_account'.");
+            verifyErr(result, "invalidParams", RpcInvalidParams, "Missing field 'source_account'.");
         }
         {
             // Non-string source_account field.
             json::Value args{depositAuthArgs(alice, becky)};
             args[jss::source_account] = 7.3;
             json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
-            verifyErr(result, "invalidParams", "Invalid field 'source_account', not a string.");
+            verifyErr(
+                result,
+                "invalidParams",
+                RpcInvalidParams,
+                "Invalid field 'source_account', not a string.");
         }
         {
             // Corrupt source_account field.
             json::Value args{depositAuthArgs(alice, becky)};
             args[jss::source_account] = "rG1QQv2nh2gr7RCZ!P8YYcBUKCCN633jCn";
             json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
-            verifyErr(result, "actMalformed", "Account malformed.");
+            verifyErr(result, "actMalformed", RpcActMalformed, "Account malformed.");
         }
         {
             // Missing destination_account field.
             json::Value args{depositAuthArgs(alice, becky)};
             args.removeMember(jss::destination_account);
             json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
-            verifyErr(result, "invalidParams", "Missing field 'destination_account'.");
+            verifyErr(
+                result, "invalidParams", RpcInvalidParams, "Missing field 'destination_account'.");
         }
         {
             // Non-string destination_account field.
@@ -196,40 +206,46 @@ public:
             args[jss::destination_account] = 7.3;
             json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
             verifyErr(
-                result, "invalidParams", "Invalid field 'destination_account', not a string.");
+                result,
+                "invalidParams",
+                RpcInvalidParams,
+                "Invalid field 'destination_account', not a string.");
         }
         {
             // Corrupt destination_account field.
             json::Value args{depositAuthArgs(alice, becky)};
             args[jss::destination_account] = "rP6P9ypfAmc!pw8SZHNwM4nvZHFXDraQas";
             json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
-            verifyErr(result, "actMalformed", "Account malformed.");
+            verifyErr(result, "actMalformed", RpcActMalformed, "Account malformed.");
         }
         {
             // Request an invalid ledger.
             json::Value const args{depositAuthArgs(alice, becky, "-1")};
             json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
             verifyErr(
-                result, "invalidParams", "Invalid field 'ledger_index', not string or number.");
+                result,
+                "invalidParams",
+                RpcInvalidParams,
+                "Invalid field 'ledger_index', not string or number.");
         }
         {
             // Request a ledger that doesn't exist yet as a string.
             json::Value const args{depositAuthArgs(alice, becky, "17")};
             json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
-            verifyErr(result, "lgrNotFound", "ledgerNotFound");
+            verifyErr(result, "lgrNotFound", RpcLgrNotFound, "ledgerNotFound");
         }
         {
             // Request a ledger that doesn't exist yet.
             json::Value args{depositAuthArgs(alice, becky)};
             args[jss::ledger_index] = 17;
             json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
-            verifyErr(result, "lgrNotFound", "ledgerNotFound");
+            verifyErr(result, "lgrNotFound", RpcLgrNotFound, "ledgerNotFound");
         }
         {
             // alice is not yet funded.
             json::Value const args{depositAuthArgs(alice, becky)};
             json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
-            verifyErr(result, "srcActNotFound", "Source account not found.");
+            verifyErr(result, "srcActNotFound", RpcSrcActNotFound, "Source account not found.");
         }
         env.fund(XRP(1000), alice);
         env.close();
@@ -237,7 +253,8 @@ public:
             // becky is not yet funded.
             json::Value const args{depositAuthArgs(alice, becky)};
             json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
-            verifyErr(result, "dstActNotFound", "Destination account not found.");
+            verifyErr(
+                result, "dstActNotFound", RpcDstActNotFound, "Destination account not found.");
         }
         env.fund(XRP(1000), becky);
         env.close();
@@ -256,9 +273,11 @@ public:
         jtx::Account const& dst,
         bool authorized,
         std::vector<std::string> credentialIDs = {},
-        std::string_view error = "")
+        std::string_view error = "",
+        ErrorCodeI code = RpcSuccess,
+        std::string_view errorMessage = "")
     {
-        BEAST_EXPECT(result[jss::status] == authorized ? jss::success : jss::error);
+        BEAST_EXPECT(result[jss::status] == (authorized ? jss::success : jss::error));
         if (result.isMember(jss::deposit_authorized))
             BEAST_EXPECT(result[jss::deposit_authorized] == authorized);
         if (authorized)
@@ -270,7 +289,11 @@ public:
 
         BEAST_EXPECT(result.isMember(jss::error) == !error.empty());
         if (!error.empty())
+        {
             BEAST_EXPECT(result[jss::error].asString() == error);
+            BEAST_EXPECT(result[jss::error_code] == code);
+            BEAST_EXPECT(result[jss::error_message].asString() == errorMessage);
+        }
 
         if (authorized)
         {
@@ -334,7 +357,15 @@ public:
             args[jss::credentials] = json::ValueType::Array;
 
             auto const jv = env.rpc("json", "deposit_authorized", args.toStyledString());
-            checkCredentialsResponse(jv[jss::result], alice, becky, false, {}, "invalidParams");
+            checkCredentialsResponse(
+                jv[jss::result],
+                alice,
+                becky,
+                false,
+                {},
+                "invalidParams",
+                RpcInvalidParams,
+                "Invalid field 'credentials', not is non-empty array of CredentialID(hash256).");
         }
 
         {
@@ -348,7 +379,15 @@ public:
             args[jss::credentials].append(3);
 
             auto const jv = env.rpc("json", "deposit_authorized", args.toStyledString());
-            checkCredentialsResponse(jv[jss::result], alice, becky, false, {}, "invalidParams");
+            checkCredentialsResponse(
+                jv[jss::result],
+                alice,
+                becky,
+                false,
+                {},
+                "invalidParams",
+                RpcInvalidParams,
+                "Invalid field 'credentials', not an array of CredentialID(hash256).");
         }
 
         {
@@ -362,7 +401,14 @@ public:
 
             auto const jv = env.rpc("json", "deposit_authorized", args.toStyledString());
             checkCredentialsResponse(
-                jv[jss::result], alice, becky, false, {"hello world"}, "invalidParams");
+                jv[jss::result],
+                alice,
+                becky,
+                false,
+                {"hello world"},
+                "invalidParams",
+                RpcInvalidParams,
+                "Invalid field 'credentials', not an array of CredentialID(hash256).");
         }
 
         {
@@ -389,7 +435,9 @@ public:
                     "0127AB8B4B29CCDBB61AA51C0799A8A6BB80B86A9899807C11ED576AF8516"
                     "473",
                 },
-                "badCredentials");
+                "badCredentials",
+                RpcBadCredentials,
+                "credentials don't exist");
         }
 
         {
@@ -403,7 +451,14 @@ public:
 
                 auto const jv = env.rpc("json", "deposit_authorized", args.toStyledString());
                 checkCredentialsResponse(
-                    jv[jss::result], alice, becky, false, {zero}, "badCredentials");
+                    jv[jss::result],
+                    alice,
+                    becky,
+                    false,
+                    {zero},
+                    "badCredentials",
+                    RpcBadCredentials,
+                    "credentials don't exist");
             }
         }
 
@@ -416,7 +471,14 @@ public:
                 "deposit_authorized",
                 depositAuthArgs(alice, becky, "validated", {credIdx}).toStyledString());
             checkCredentialsResponse(
-                jv[jss::result], alice, becky, false, {credIdx}, "badCredentials");
+                jv[jss::result],
+                alice,
+                becky,
+                false,
+                {credIdx},
+                "badCredentials",
+                RpcBadCredentials,
+                "credentials aren't accepted");
         }
 
         // alice accept credentials
@@ -430,7 +492,14 @@ public:
                 "deposit_authorized",
                 depositAuthArgs(alice, becky, "validated", {credIdx, credIdx}).toStyledString());
             checkCredentialsResponse(
-                jv[jss::result], alice, becky, false, {credIdx, credIdx}, "badCredentials");
+                jv[jss::result],
+                alice,
+                becky,
+                false,
+                {credIdx, credIdx},
+                "badCredentials",
+                RpcBadCredentials,
+                "duplicates in credentials");
         }
 
         {
@@ -453,7 +522,14 @@ public:
                 "deposit_authorized",
                 depositAuthArgs(alice, becky, "validated", kCredIds).toStyledString());
             checkCredentialsResponse(
-                jv[jss::result], alice, becky, false, kCredIds, "invalidParams");
+                jv[jss::result],
+                alice,
+                becky,
+                false,
+                kCredIds,
+                "invalidParams",
+                RpcInvalidParams,
+                "Invalid field 'credentials', not array too long.");
         }
 
         {
@@ -500,7 +576,14 @@ public:
                 "deposit_authorized",
                 depositAuthArgs(becky, alice, "validated", {credDiana}).toStyledString());
             checkCredentialsResponse(
-                jv[jss::result], becky, alice, false, {credDiana}, "badCredentials");
+                jv[jss::result],
+                becky,
+                alice,
+                false,
+                {credDiana},
+                "badCredentials",
+                RpcBadCredentials,
+                "credentials doesn't belong to the root account");
         }
 
         {
@@ -549,7 +632,14 @@ public:
                     depositAuthArgs(alice, becky, "validated", {credIdx2}).toStyledString());
 
                 checkCredentialsResponse(
-                    jv[jss::result], alice, becky, false, {credIdx2}, "badCredentials");
+                    jv[jss::result],
+                    alice,
+                    becky,
+                    false,
+                    {credIdx2},
+                    "badCredentials",
+                    RpcBadCredentials,
+                    "credentials are expired");
             }
         }
     }

src/test/rpc/Feature_test.cpp

@@ -11,6 +11,7 @@
 #include <xrpl/json/to_string.h>
 #include <xrpl/ledger/AmendmentTable.h>
 #include <xrpl/ledger/View.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/digest.h>
 #include <xrpl/protocol/jss.h>
@@ -206,6 +207,7 @@ class Feature_test : public beast::unit_test::Suite
         // feature names are case-sensitive - expect error here
         jrr = env.rpc("feature", "fMM")[jss::result];
         BEAST_EXPECT(jrr[jss::error] == "badFeature");
+        BEAST_EXPECT(jrr[jss::error_code] == RpcBadFeature);
         BEAST_EXPECT(jrr[jss::error_message] == "Feature unknown or invalid.");
 
         // Test feature name size checks
@@ -253,6 +255,7 @@ class Feature_test : public beast::unit_test::Suite
             params[jss::feature] = param;
             auto jrr = env.rpc("json", "feature", to_string(params))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid parameters.");
         };
 
@@ -266,6 +269,7 @@ class Feature_test : public beast::unit_test::Suite
         {
             auto jrr = env.rpc("feature", "AllTheThings")[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "badFeature");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcBadFeature);
             BEAST_EXPECT(jrr[jss::error_message] == "Feature unknown or invalid.");
         }
     }
@@ -320,6 +324,7 @@ class Feature_test : public beast::unit_test::Suite
                 "EF";
             auto const result = env.rpc("json", "feature", to_string(params))[jss::result];
             BEAST_EXPECTS(result[jss::error] == "badFeature", result.toStyledString());
+            BEAST_EXPECT(result[jss::error_code] == RpcBadFeature);
             BEAST_EXPECT(result[jss::error_message] == "Feature unknown or invalid.");
         }
 
@@ -332,6 +337,7 @@ class Feature_test : public beast::unit_test::Suite
             params[jss::vetoed] = true;
             auto const result = env.rpc("json", "feature", to_string(params))[jss::result];
             BEAST_EXPECTS(result[jss::error] == "noPermission", result[jss::error].asString());
+            BEAST_EXPECT(result[jss::error_code] == RpcNoPermission);
             BEAST_EXPECT(
                 result[jss::error_message] == "You don't have permission for this command.");
         }
@@ -513,6 +519,7 @@ class Feature_test : public beast::unit_test::Suite
 
             auto const result = env.rpc("json", "feature", to_string(params))[jss::result];
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Invalid parameters.");
         };
 
@@ -521,6 +528,7 @@ class Feature_test : public beast::unit_test::Suite
         // anything other than accept or reject is an error
         jrr = env.rpc("feature", kFeatureName, "maybe");
         BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+        BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
         BEAST_EXPECT(jrr[jss::error_message] == "Invalid parameters.");
     }
 
@@ -584,6 +592,7 @@ class Feature_test : public beast::unit_test::Suite
         // anything other than accept or reject is an error
         jrr = env.rpc("feature", featureName, "maybe");
         BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+        BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
         BEAST_EXPECT(jrr[jss::error_message] == "Invalid parameters.");
     }
 

src/test/rpc/GatewayBalances_test.cpp

@@ -10,6 +10,7 @@
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/ApiVersion.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/TxFlags.h>
@@ -172,7 +173,12 @@ public:
 
             auto response = jv[jss::result];
             auto const error = apiVersion < 2u ? "invalidHotWallet" : "invalidParams";
+            auto const errorCode = apiVersion < 2u ? RpcInvalidHotwallet : RpcInvalidParams;
+            auto const errorMessage =
+                apiVersion < 2u ? "Invalid hotwallet." : "Invalid parameters.";
             BEAST_EXPECT(response[jss::error] == error);
+            BEAST_EXPECT(response[jss::error_code] == errorCode);
+            BEAST_EXPECT(response[jss::error_message] == errorMessage);
         });
     }
 
@@ -201,6 +207,8 @@ public:
             auto jv = wsc->invoke("gateway_balances", qry);
             expect(jv[jss::status] == "error");
             BEAST_EXPECT(jv[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(jv[jss::result][jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(jv[jss::result][jss::error_message] == "Invalid field 'account'.");
         });
 
         // The same applies to a non-string "ident".
@@ -212,6 +220,8 @@ public:
             auto jv = wsc->invoke("gateway_balances", qry2);
             expect(jv[jss::status] == "error");
             BEAST_EXPECT(jv[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(jv[jss::result][jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(jv[jss::result][jss::error_message] == "Invalid field 'ident'.");
         });
     }
 

src/test/rpc/GetAggregatePrice_test.cpp

@@ -12,6 +12,7 @@
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/core/ServiceRegistry.h>
 #include <xrpl/ledger/OpenView.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/SField.h>
@@ -42,10 +43,14 @@ public:
             auto const baseFee = env.current()->fees().base;
             // missing base_asset
             auto ret = Oracle::aggregatePrice(env, std::nullopt, "USD", kOracles);
+            BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
+            BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(ret[jss::error_message].asString() == "Missing field 'base_asset'.");
 
             // missing quote_asset
             ret = Oracle::aggregatePrice(env, "XRP", std::nullopt, kOracles);
+            BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
+            BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(ret[jss::error_message].asString() == "Missing field 'quote_asset'.");
 
             // invalid base_asset, quote_asset
@@ -69,28 +74,44 @@ public:
             {
                 ret = Oracle::aggregatePrice(env, "USD", v, kOracles);
                 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
+                BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(ret[jss::error_message].asString() == "Invalid parameters.");
                 ret = Oracle::aggregatePrice(env, v, "USD", kOracles);
                 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
+                BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(ret[jss::error_message].asString() == "Invalid parameters.");
                 ret = Oracle::aggregatePrice(env, v, v, kOracles);
                 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
+                BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(ret[jss::error_message].asString() == "Invalid parameters.");
             }
 
             // missing oracles array
             ret = Oracle::aggregatePrice(env, "XRP", "USD");
+            BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
+            BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(ret[jss::error_message].asString() == "Missing field 'oracles'.");
 
             // empty oracles array
             ret = Oracle::aggregatePrice(env, "XRP", "USD", OraclesData{});
             BEAST_EXPECT(ret[jss::error].asString() == "oracleMalformed");
+            BEAST_EXPECT(ret[jss::error_code] == RpcOracleMalformed);
+            BEAST_EXPECT(ret[jss::error_message].asString() == "Oracle request is malformed.");
 
             // no token pairs found
             ret = Oracle::aggregatePrice(env, "YAN", "USD", kOracles);
             BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound");
+            BEAST_EXPECT(ret[jss::error_code] == RpcObjectNotFound);
+            BEAST_EXPECT(
+                ret[jss::error_message].asString() == "The requested object was not found.");
 
             // invalid oracle document id
             // id doesn't exist
             ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, 2}}});
             BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound");
+            BEAST_EXPECT(ret[jss::error_code] == RpcObjectNotFound);
+            BEAST_EXPECT(
+                ret[jss::error_message].asString() == "The requested object was not found.");
             // invalid values
             std::vector<AnyValue> const invalidDocument = {kNoneTag, 1.2, -1, "", "none", "1.2"};
             for (auto const& v : invalidDocument)
@@ -99,17 +120,26 @@ public:
                 json::Value jv;
                 toJson(jv, v);
                 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
+                BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(ret[jss::error_message].asString() == "Invalid parameters.");
             }
             // missing document id
             ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, std::nullopt}}});
             BEAST_EXPECT(ret[jss::error].asString() == "oracleMalformed");
+            BEAST_EXPECT(ret[jss::error_code] == RpcOracleMalformed);
+            BEAST_EXPECT(ret[jss::error_message].asString() == "Oracle request is malformed.");
 
             // invalid owner
             ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{some, 1}}});
             BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound");
+            BEAST_EXPECT(ret[jss::error_code] == RpcObjectNotFound);
+            BEAST_EXPECT(
+                ret[jss::error_message].asString() == "The requested object was not found.");
             // missing account
             ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{std::nullopt, 1}}});
             BEAST_EXPECT(ret[jss::error].asString() == "oracleMalformed");
+            BEAST_EXPECT(ret[jss::error_code] == RpcOracleMalformed);
+            BEAST_EXPECT(ret[jss::error_message].asString() == "Oracle request is malformed.");
 
             // oracles have wrong asset pair
             env.fund(XRP(1'000), owner);
@@ -122,6 +152,9 @@ public:
                 });
             ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, oracle.documentID()}}});
             BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound");
+            BEAST_EXPECT(ret[jss::error_code] == RpcObjectNotFound);
+            BEAST_EXPECT(
+                ret[jss::error_message].asString() == "The requested object was not found.");
 
             // invalid trim value
             std::vector<AnyValue> const invalidTrim = {kNoneTag, 0, 26, -1, 1.2, "", "none", "1.2"};
@@ -130,6 +163,8 @@ public:
                 ret =
                     Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, oracle.documentID()}}}, v);
                 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
+                BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(ret[jss::error_message].asString() == "Invalid parameters.");
             }
 
             // invalid time threshold value
@@ -139,6 +174,8 @@ public:
                 ret = Oracle::aggregatePrice(
                     env, "XRP", "USD", {{{owner, oracle.documentID()}}}, std::nullopt, v);
                 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
+                BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
+                BEAST_EXPECT(ret[jss::error_message].asString() == "Invalid parameters.");
             }
         }
 
@@ -157,6 +194,8 @@ public:
             }
             auto const ret = Oracle::aggregatePrice(env, "XRP", "USD", oracles);
             BEAST_EXPECT(ret[jss::error].asString() == "oracleMalformed");
+            BEAST_EXPECT(ret[jss::error_code] == RpcOracleMalformed);
+            BEAST_EXPECT(ret[jss::error_message].asString() == "Oracle request is malformed.");
         }
     }
 
@@ -457,6 +496,8 @@ public:
         // a nullptr dereference.
         auto const ret = Oracle::aggregatePrice(env, "XRP", "USD", oracles);
         BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound");
+        BEAST_EXPECT(ret[jss::error_code] == RpcObjectNotFound);
+        BEAST_EXPECT(ret[jss::error_message].asString() == "The requested object was not found.");
     }
 
     void

src/test/rpc/KeyGeneration_test.cpp

@@ -209,7 +209,12 @@ public:
         params[jss::seed_hex] = strings.masterSeedHex;
 
         // Secret fields are mutually exclusive.
-        BEAST_EXPECT(containsError(walletPropose(params)));
+        auto const result = walletPropose(params);
+        BEAST_EXPECT(result[jss::error] == "invalidParams");
+        BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
+        BEAST_EXPECT(
+            result[jss::error_message] ==
+            "Exactly one of the following must be specified: passphrase, seed or seed_hex");
     }
 
     void
@@ -223,7 +228,8 @@ public:
             params[jss::key_type] = "secp256k1";
             params[jss::passphrase] = 20160506;
             auto result = walletPropose(params);
-            BEAST_EXPECT(containsError(result));
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Invalid field 'passphrase', not string.");
         }
 
@@ -232,7 +238,8 @@ public:
             params[jss::key_type] = "secp256k1";
             params[jss::seed] = json::ValueType::Object;
             auto result = walletPropose(params);
-            BEAST_EXPECT(containsError(result));
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Invalid field 'seed', not string.");
         }
 
@@ -241,7 +248,8 @@ public:
             params[jss::key_type] = "ed25519";
             params[jss::seed_hex] = json::ValueType::Array;
             auto result = walletPropose(params);
-            BEAST_EXPECT(containsError(result));
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Invalid field 'seed_hex', not string.");
         }
 
@@ -253,7 +261,8 @@ public:
             params[jss::seed_hex] = common::gMasterSeedHex;
             params[jss::seed] = common::gMasterSeed;
             auto result = walletPropose(params);
-            BEAST_EXPECT(containsError(result));
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 result[jss::error_message] ==
                 "Exactly one of the following must be specified: passphrase, "
@@ -266,7 +275,8 @@ public:
             params[jss::key_type] = "prime256v1";
             params[jss::passphrase] = common::gMasterKey;
             auto result = walletPropose(params);
-            BEAST_EXPECT(containsError(result));
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Invalid parameters.");
         }
 
@@ -275,7 +285,8 @@ public:
             params[jss::key_type] = json::ValueType::Object;
             params[jss::seed_hex] = common::gMasterSeedHex;
             auto result = walletPropose(params);
-            BEAST_EXPECT(containsError(result));
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Invalid field 'key_type', not string.");
         }
 
@@ -284,7 +295,8 @@ public:
             params[jss::key_type] = json::ValueType::Array;
             params[jss::seed] = common::gMasterSeed;
             auto result = walletPropose(params);
-            BEAST_EXPECT(containsError(result));
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Invalid field 'key_type', not string.");
         }
     }
@@ -402,8 +414,9 @@ public:
             json::Value error;
             params[jss::secret] = 314159265;
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'secret', not string.");
         }
 
@@ -414,8 +427,9 @@ public:
             params[jss::secret].append("array:0");
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'secret', not string.");
         }
 
@@ -427,8 +441,9 @@ public:
             params[jss::secret]["number"] = 702;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'secret', not string.");
         }
 
@@ -440,8 +455,9 @@ public:
             params[jss::secret] = common::gMasterSeed;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 error[jss::error_message] ==
                 "The secret field is not allowed if key_type is used.");
@@ -455,8 +471,9 @@ public:
             params[jss::passphrase] = common::gMasterKey;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'key_type'.");
         }
 
@@ -467,8 +484,9 @@ public:
             params[jss::seed_hex] = common::gMasterSeedHex;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'key_type', not string.");
         }
 
@@ -479,8 +497,9 @@ public:
             params[jss::seed] = common::gMasterSeed;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'key_type', not string.");
         }
 
@@ -492,8 +511,9 @@ public:
             params[jss::passphrase] = 1234567890;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'passphrase', not string.");
         }
 
@@ -504,8 +524,9 @@ public:
             params[jss::passphrase] = json::ValueType::Object;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'passphrase', not string.");
         }
 
@@ -516,8 +537,9 @@ public:
             params[jss::passphrase] = json::ValueType::Array;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'passphrase', not string.");
         }
 
@@ -528,8 +550,9 @@ public:
             params[jss::passphrase] = "";
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "badSeed");
+            BEAST_EXPECT(error[jss::error_code] == RpcBadSeed);
             BEAST_EXPECT(error[jss::error_message] == "Disallowed seed.");
         }
 
@@ -541,8 +564,9 @@ public:
             params[jss::seed] = 443556;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'seed', not string.");
         }
 
@@ -553,8 +577,9 @@ public:
             params[jss::seed] = json::ValueType::Object;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'seed', not string.");
         }
 
@@ -565,8 +590,9 @@ public:
             params[jss::seed] = json::ValueType::Array;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'seed', not string.");
         }
 
@@ -577,8 +603,9 @@ public:
             params[jss::seed] = "";
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "badSeed");
+            BEAST_EXPECT(error[jss::error_code] == RpcBadSeed);
             BEAST_EXPECT(error[jss::error_message] == "Disallowed seed.");
         }
 
@@ -589,8 +616,9 @@ public:
             params[jss::seed] = "s M V s h z D F p t Z E m h s";
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "badSeed");
+            BEAST_EXPECT(error[jss::error_code] == RpcBadSeed);
             BEAST_EXPECT(error[jss::error_message] == "Disallowed seed.");
         }
 
@@ -601,8 +629,9 @@ public:
             params[jss::seed] = "pnnjkbnobnml43679nbvjdsklnbjs";
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "badSeed");
+            BEAST_EXPECT(error[jss::error_code] == RpcBadSeed);
             BEAST_EXPECT(error[jss::error_message] == "Disallowed seed.");
         }
 
@@ -614,8 +643,9 @@ public:
             params[jss::seed_hex] = 443556;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'seed_hex', not string.");
         }
 
@@ -626,8 +656,9 @@ public:
             params[jss::seed_hex] = json::ValueType::Object;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'seed_hex', not string.");
         }
 
@@ -638,8 +669,9 @@ public:
             params[jss::seed_hex] = json::ValueType::Array;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "invalidParams");
+            BEAST_EXPECT(error[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(error[jss::error_message] == "Invalid field 'seed_hex', not string.");
         }
 
@@ -650,8 +682,9 @@ public:
             params[jss::seed_hex] = "";
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "badSeed");
+            BEAST_EXPECT(error[jss::error_code] == RpcBadSeed);
             BEAST_EXPECT(error[jss::error_message] == "Disallowed seed.");
         }
 
@@ -662,8 +695,9 @@ public:
             params[jss::seed_hex] = "A670A19B";
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "badSeed");
+            BEAST_EXPECT(error[jss::error_code] == RpcBadSeed);
             BEAST_EXPECT(error[jss::error_message] == "Disallowed seed.");
         }
 
@@ -674,8 +708,9 @@ public:
             params[jss::seed_hex] = common::gPassphrase;
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "badSeed");
+            BEAST_EXPECT(error[jss::error_code] == RpcBadSeed);
             BEAST_EXPECT(error[jss::error_message] == "Disallowed seed.");
         }
 
@@ -686,8 +721,9 @@ public:
             params[jss::seed_hex] = "BE6A670A19B209E112146D0A7ED2AAD72567D0FC913";
 
             auto const ret = keypairForSignature(params, error);
-            BEAST_EXPECT(containsError(error));
             BEAST_EXPECT(!ret);
+            BEAST_EXPECT(error[jss::error] == "badSeed");
+            BEAST_EXPECT(error[jss::error_code] == RpcBadSeed);
             BEAST_EXPECT(error[jss::error_message] == "Disallowed seed.");
         }
     }
@@ -723,7 +759,8 @@ public:
 
                 auto const ret = keypairForSignature(params, error);
 
-                BEAST_EXPECT(containsError(error));
+                BEAST_EXPECT(error[jss::error] == "badSeed");
+                BEAST_EXPECT(error[jss::error_code] == RpcBadSeed);
                 BEAST_EXPECT(
                     error[jss::error_message] == "Specified seed is for an Ed25519 wallet.");
             }
@@ -754,7 +791,8 @@ public:
 
                 auto const ret = keypairForSignature(params, error);
 
-                BEAST_EXPECT(containsError(error));
+                BEAST_EXPECT(error[jss::error] == "badSeed");
+                BEAST_EXPECT(error[jss::error_code] == RpcBadSeed);
                 BEAST_EXPECT(
                     error[jss::error_message] == "Specified seed is for an Ed25519 wallet.");
             }

src/test/rpc/LedgerData_test.cpp

@@ -17,6 +17,7 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
 #include <xrpl/ledger/View.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/Serializer.h>
@@ -131,8 +132,9 @@ public:
             json::Value jvParams;
             jvParams[jss::limit] = "0";  // NOT an integer
             auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
-            BEAST_EXPECT(jrr[jss::error] == "invalidParams");
             BEAST_EXPECT(jrr[jss::status] == "error");
+            BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'limit', not integer.");
         }
 
@@ -141,8 +143,9 @@ public:
             json::Value jvParams;
             jvParams[jss::marker] = "NOT_A_MARKER";
             auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
-            BEAST_EXPECT(jrr[jss::error] == "invalidParams");
             BEAST_EXPECT(jrr[jss::status] == "error");
+            BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'marker', not valid.");
         }
 
@@ -151,8 +154,9 @@ public:
             json::Value jvParams;
             jvParams[jss::marker] = 1;
             auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
-            BEAST_EXPECT(jrr[jss::error] == "invalidParams");
             BEAST_EXPECT(jrr[jss::status] == "error");
+            BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'marker', not valid.");
         }
 
@@ -161,8 +165,9 @@ public:
             json::Value jvParams;
             jvParams[jss::ledger_index] = 10u;
             auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
-            BEAST_EXPECT(jrr[jss::error] == "lgrNotFound");
             BEAST_EXPECT(jrr[jss::status] == "error");
+            BEAST_EXPECT(jrr[jss::error] == "lgrNotFound");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcLgrNotFound);
             BEAST_EXPECT(jrr[jss::error_message] == "ledgerNotFound");
         }
 
@@ -171,8 +176,9 @@ public:
             json::Value jvParams;
             jvParams[jss::binary] = "true";
             auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
-            BEAST_EXPECT(jrr[jss::error] == "invalidParams");
             BEAST_EXPECT(jrr[jss::status] == "error");
+            BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'binary', not boolean.");
         }
     }
@@ -459,8 +465,8 @@ public:
                 jvParams[jss::ledger_index] = "current";
                 jvParams[jss::type] = "misspelling";
                 auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
-                BEAST_EXPECT(jrr.isMember("error"));
                 BEAST_EXPECT(jrr["error"] == "invalidParams");
+                BEAST_EXPECT(jrr["error_code"] == RpcInvalidParams);
                 BEAST_EXPECT(jrr["error_message"] == "Invalid field 'type'.");
             }
         }

src/test/rpc/LedgerEntry_test.cpp

@@ -153,6 +153,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
     checkErrorValue(
         json::Value const& jv,
         std::string const& err,
+        ErrorCodeI code,
         std::string const& msg,
         std::source_location const location = std::source_location::current())
     {
@@ -165,6 +166,14 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 "Expected error " + err + ", received " + jv[jss::error].asString() + ", at line " +
                     std::to_string(location.line()) + ", " + jv.toStyledString());
         }
+        if (BEAST_EXPECT(jv.isMember(jss::error_code)))
+        {
+            BEAST_EXPECTS(
+                jv[jss::error_code] == code,
+                "Expected error code " + std::to_string(code) + ", received " +
+                    jv[jss::error_code].asString() + ", at line " +
+                    std::to_string(location.line()) + ", " + jv.toStyledString());
+        }
         if (msg.empty())
         {
             BEAST_EXPECTS(
@@ -340,12 +349,21 @@ class LedgerEntry_test : public beast::unit_test::Suite
                     apiVersion, "json", "ledger_entry", to_string(correctRequest))[jss::result];
                 if (apiVersion < 2u)
                 {
-                    checkErrorValue(jrr, "unknownOption", "", location);
+                    BEAST_EXPECTS(jrr[jss::status] == "error", std::to_string(location.line()));
+                    BEAST_EXPECTS(
+                        jrr[jss::error] == "unknownOption", std::to_string(location.line()));
+                    BEAST_EXPECTS(!jrr.isMember(jss::error_code), std::to_string(location.line()));
+                    BEAST_EXPECTS(
+                        jrr[jss::error_message].isNull(), std::to_string(location.line()));
                 }
                 else
                 {
                     checkErrorValue(
-                        jrr, "invalidParams", "No ledger_entry params provided.", location);
+                        jrr,
+                        "invalidParams",
+                        RpcInvalidParams,
+                        "No ledger_entry params provided.",
+                        location);
                 }
             }
             auto const tryField = [&](json::Value fieldValue) -> void {
@@ -354,7 +372,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
                     apiVersion, "json", "ledger_entry", to_string(correctRequest))[jss::result];
                 auto const expectedErrMsg = rpc::expectedFieldMessage(
                     fieldName, typeNameOverride.value_or(getTypeName(typeID)));
-                checkErrorValue(jrr, expectedError, expectedErrMsg, location);
+                checkErrorValue(jrr, expectedError, RpcInvalidParams, expectedErrMsg, location);
             };
 
             auto const& badValues = getBadValues(typeID);
@@ -387,13 +405,21 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 json::Value const jrr = env.rpc(
                     apiVersion, "json", "ledger_entry", to_string(correctRequest))[jss::result];
                 checkErrorValue(
-                    jrr, "malformedRequest", rpc::missingFieldMessage(fieldName.cStr()), location);
+                    jrr,
+                    "malformedRequest",
+                    RpcInvalidParams,
+                    rpc::missingFieldMessage(fieldName.cStr()),
+                    location);
 
                 correctRequest[parentFieldName][fieldName] = json::ValueType::Null;
                 json::Value const jrr2 = env.rpc(
                     apiVersion, "json", "ledger_entry", to_string(correctRequest))[jss::result];
                 checkErrorValue(
-                    jrr2, "malformedRequest", rpc::missingFieldMessage(fieldName.cStr()), location);
+                    jrr2,
+                    "malformedRequest",
+                    RpcInvalidParams,
+                    rpc::missingFieldMessage(fieldName.cStr()),
+                    location);
             }
             auto const tryField = [&](json::Value fieldValue) -> void {
                 correctRequest[parentFieldName][fieldName] = fieldValue;
@@ -403,6 +429,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 checkErrorValue(
                     jrr,
                     expectedError,
+                    RpcInvalidParams,
                     rpc::expectedFieldMessage(fieldName, getTypeName(typeID)),
                     location);
             };
@@ -497,7 +524,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                 "AA";
             auto const jrr = env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "lgrNotFound", "ledgerNotFound");
+            checkErrorValue(jrr, "lgrNotFound", RpcLgrNotFound, "ledgerNotFound");
         }
         {
             // Missing ledger_entry ledger_hash
@@ -511,7 +538,10 @@ class LedgerEntry_test : public beast::unit_test::Suite
                     json::Value const jrr = env.rpc(
                         apiVersion, "json", "ledger_entry", to_string(jvParams))[jss::result];
                     checkErrorValue(
-                        jrr, "invalidParams", "Invalid field 'ledger_hash', not hex string.");
+                        jrr,
+                        "invalidParams",
+                        RpcInvalidParams,
+                        "Invalid field 'ledger_hash', not hex string.");
                 };
 
                 auto const& badValues = getBadValues(typeId);
@@ -530,7 +560,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 "00000000000000000000000000000000000000000000000000000000000000"
                 "00";
             auto const jrr = env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
 
         forAllApiVersions([&, this](unsigned apiVersion) {
@@ -546,11 +576,15 @@ class LedgerEntry_test : public beast::unit_test::Suite
 
                 if (apiVersion < 2u)
                 {
-                    checkErrorValue(jrr, "unknownOption", "");
+                    BEAST_EXPECT(jrr[jss::status] == "error");
+                    BEAST_EXPECT(jrr[jss::error] == "unknownOption");
+                    BEAST_EXPECT(!jrr.isMember(jss::error_code));
+                    BEAST_EXPECT(jrr[jss::error_message].isNull());
                 }
                 else
                 {
-                    checkErrorValue(jrr, "invalidParams", "No ledger_entry params provided.");
+                    checkErrorValue(
+                        jrr, "invalidParams", RpcInvalidParams, "No ledger_entry params provided.");
                 }
             }
         });
@@ -655,7 +689,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
     }
 
@@ -854,7 +888,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
         {
             // Request an index that is not a check.  We'll use alice's
@@ -872,7 +906,8 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "unexpectedLedgerType", "Unexpected ledger type.");
+            checkErrorValue(
+                jrr, "unexpectedLedgerType", RpcUnexpectedLedgerType, "Unexpected ledger type.");
         }
         {
             // Check malformed cases
@@ -931,7 +966,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 env,
                 "48004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288B"
                 "E4");
-            checkErrorValue(jv[jss::result], "entryNotFound", "Entry not found.");
+            checkErrorValue(jv[jss::result], "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
 
         {
@@ -1126,7 +1161,8 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 auto const expectedErrMsg = fieldValue.isNull()
                     ? rpc::missingFieldMessage(jss::issuer.cStr())
                     : rpc::expectedFieldMessage(jss::issuer, "AccountID");
-                checkErrorValue(jrr, "malformedAuthorizedCredentials", expectedErrMsg);
+                checkErrorValue(
+                    jrr, "malformedAuthorizedCredentials", RpcInvalidParams, expectedErrMsg);
             };
 
             auto const& badValues = getBadValues(FieldType::AccountField);
@@ -1155,6 +1191,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             checkErrorValue(
                 jrr[jss::result],
                 "malformedAuthorizedCredentials",
+                RpcInvalidParams,
                 rpc::expectedFieldMessage(jss::authorized_credentials, "array"));
         }
 
@@ -1177,7 +1214,8 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 auto const expectedErrMsg = fieldValue.isNull()
                     ? rpc::missingFieldMessage(jss::credential_type.cStr())
                     : rpc::expectedFieldMessage(jss::credential_type, "hex string");
-                checkErrorValue(jrr, "malformedAuthorizedCredentials", expectedErrMsg);
+                checkErrorValue(
+                    jrr, "malformedAuthorizedCredentials", RpcInvalidParams, expectedErrMsg);
             };
 
             auto const& badValues = getBadValues(FieldType::BlobField);
@@ -1207,6 +1245,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             checkErrorValue(
                 jrr[jss::result],
                 "malformedRequest",
+                RpcInvalidParams,
                 "Must have exactly one of `authorized` and "
                 "`authorized_credentials`.");
         }
@@ -1239,6 +1278,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             checkErrorValue(
                 jrr[jss::result],
                 "malformedAuthorizedCredentials",
+                RpcInvalidParams,
                 "Invalid field 'authorized_credentials', not array of objects.");
         }
 
@@ -1257,6 +1297,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             checkErrorValue(
                 jrr[jss::result],
                 "malformedAuthorizedCredentials",
+                RpcInvalidParams,
                 "Invalid field 'authorized_credentials', not array of objects.");
         }
 
@@ -1271,6 +1312,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             checkErrorValue(
                 jrr[jss::result],
                 "malformedAuthorizedCredentials",
+                RpcInvalidParams,
                 "Invalid field 'authorized_credentials', array empty.");
         }
 
@@ -1308,6 +1350,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             checkErrorValue(
                 jrr[jss::result],
                 "malformedAuthorizedCredentials",
+                RpcInvalidParams,
                 "Invalid field 'authorized_credentials', array too long.");
         }
     }
@@ -1443,7 +1486,10 @@ class LedgerEntry_test : public beast::unit_test::Suite
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
             checkErrorValue(
-                jrr, "malformedRequest", "Must have exactly one of `owner` and `dir_root` fields.");
+                jrr,
+                "malformedRequest",
+                RpcInvalidParams,
+                "Must have exactly one of `owner` and `dir_root` fields.");
         }
         {
             // Incomplete directory object.  Missing both dir_root and owner.
@@ -1454,7 +1500,10 @@ class LedgerEntry_test : public beast::unit_test::Suite
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
             checkErrorValue(
-                jrr, "malformedRequest", "Must have exactly one of `owner` and `dir_root` fields.");
+                jrr,
+                "malformedRequest",
+                RpcInvalidParams,
+                "Must have exactly one of `owner` and `dir_root` fields.");
         }
     }
 
@@ -1617,7 +1666,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::nft_offer][jss::seq] = offerSeq + 1000;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
 
         // negative tests
@@ -1835,7 +1884,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
         {
             // Request an index that is not a payment channel.
@@ -1844,7 +1893,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
 
         {
@@ -1919,6 +1968,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 checkErrorValue(
                     jrr,
                     "malformedRequest",
+                    RpcInvalidParams,
                     "Invalid field 'accounts', not length-2 array of "
                     "Accounts.");
             }
@@ -1937,6 +1987,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 checkErrorValue(
                     jrr,
                     "malformedRequest",
+                    RpcInvalidParams,
                     "Invalid field 'accounts', not length-2 array of "
                     "Accounts.");
             }
@@ -1957,6 +2008,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
                         checkErrorValue(
                             jrr,
                             "malformedAddress",
+                            RpcInvalidParams,
                             rpc::expectedFieldMessage(jss::accounts, "array of Accounts"));
                     }
 
@@ -1972,6 +2024,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
                         checkErrorValue(
                             jrr,
                             "malformedAddress",
+                            RpcInvalidParams,
                             rpc::expectedFieldMessage(jss::accounts, "array of Accounts"));
                     }
                 };
@@ -1994,7 +2047,8 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 jvParams[jss::ledger_hash] = ledgerHash;
                 json::Value const jrr =
                     env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-                checkErrorValue(jrr, "malformedRequest", "Cannot have a trustline to self.");
+                checkErrorValue(
+                    jrr, "malformedRequest", RpcInvalidParams, "Cannot have a trustline to self.");
             }
         }
     }
@@ -2048,7 +2102,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
         {
             // Request an index that is not a signer list.
@@ -2057,7 +2111,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
 
         {
@@ -2148,7 +2202,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
         {
             // First real ticket requested by index.
@@ -2184,7 +2238,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
         {
             // Request a ticket using an account root entry.
@@ -2193,7 +2247,8 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "unexpectedLedgerType", "Unexpected ledger type.");
+            checkErrorValue(
+                jrr, "unexpectedLedgerType", RpcUnexpectedLedgerType, "Unexpected ledger type.");
         }
 
         {
@@ -2261,7 +2316,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::transaction_proposal][jss::ticket_seq] = ticketSeq + 1;
             jvParams[jss::ledger_hash] = ledgerHash;
             auto const jrr = env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
         {
             // Lookup by an index of the wrong entry type.
@@ -2269,7 +2324,8 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::transaction_proposal] = to_string(keylet::account(target).key);
             jvParams[jss::ledger_hash] = ledgerHash;
             auto const jrr = env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "unexpectedLedgerType", "Unexpected ledger type.");
+            checkErrorValue(
+                jrr, "unexpectedLedgerType", RpcUnexpectedLedgerType, "Unexpected ledger type.");
         }
 
         {
@@ -2333,7 +2389,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
         {
             // Malformed DID index
@@ -2455,7 +2511,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
         {
             // Request the MPToken using its owner + mptIssuanceID.
@@ -2478,7 +2534,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = ledgerHash;
             json::Value const jrr =
                 env.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
         {
             // Malformed MPTIssuance index
@@ -2546,7 +2602,8 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 "12F1F1F1F180D67377B2FAB292A31C922470326268D2B9B74CD1E582645B9A"
                 "DE";
             auto const jrr = env.rpc("json", "ledger_entry", to_string(params));
-            checkErrorValue(jrr[jss::result], "entryNotFound", "Entry not found.");
+            checkErrorValue(
+                jrr[jss::result], "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
         {
             // test basic malformed scenarios
@@ -2592,7 +2649,9 @@ class LedgerEntry_test : public beast::unit_test::Suite
         auto checkResult = [&](bool good,
                                json::Value const& jv,
                                json::StaticString const& expectedType,
-                               std::optional<std::string> const& expectedError = {}) {
+                               std::optional<std::string> const& expectedError = {},
+                               ErrorCodeI expectedCode = RpcEntryNotFound,
+                               std::string const& expectedMessage = "Entry not found.") {
             if (good)
             {
                 BEAST_EXPECTS(
@@ -2607,9 +2666,10 @@ class LedgerEntry_test : public beast::unit_test::Suite
             {
                 BEAST_EXPECTS(
                     jv.isObject() && jv.isMember(jss::result) &&
-                        jv[jss::result].isMember(jss::error) &&
                         !jv[jss::result].isMember(jss::node) &&
-                        jv[jss::result][jss::error] == expectedError.value_or("entryNotFound"),
+                        jv[jss::result][jss::error] == expectedError.value_or("entryNotFound") &&
+                        jv[jss::result][jss::error_code] == expectedCode &&
+                        jv[jss::result][jss::error_message] == expectedMessage,
                     to_string(jv));
             }
         };
@@ -2640,7 +2700,13 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 params[jss::ledger_index] = jss::validated;
                 params[field] = json::ValueType::Null;
                 auto const jv = env.rpc("json", "ledger_entry", to_string(params));
-                checkResult(false, jv, expectedType, "malformedRequest");
+                checkResult(
+                    false,
+                    jv,
+                    expectedType,
+                    "malformedRequest",
+                    RpcInvalidParams,
+                    rpc::expectedFieldMessage(field, "hex string"));
                 BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
             }
 
@@ -2650,7 +2716,13 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 params[jss::ledger_index] = jss::validated;
                 params[field] = "arbitrary string";
                 auto const jv = env.rpc("json", "ledger_entry", to_string(params));
-                checkResult(false, jv, expectedType, "malformedRequest");
+                checkResult(
+                    false,
+                    jv,
+                    expectedType,
+                    "malformedRequest",
+                    RpcInvalidParams,
+                    rpc::expectedFieldMessage(field, "hex string"));
                 BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
             }
 
@@ -2660,7 +2732,13 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 params[jss::ledger_index] = jss::validated;
                 params[field] = false;
                 auto const jv = env.rpc("json", "ledger_entry", to_string(params));
-                checkResult(false, jv, expectedType, "invalidParams");
+                checkResult(
+                    false,
+                    jv,
+                    expectedType,
+                    "invalidParams",
+                    RpcInvalidParams,
+                    rpc::expectedFieldMessage(field, "true"));
                 BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
             }
 
@@ -2672,7 +2750,8 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 params[jss::ledger_index] = jss::validated;
                 params[field] = badKey;
                 auto const jv = env.rpc("json", "ledger_entry", to_string(params));
-                checkResult(false, jv, expectedType, "entryNotFound");
+                checkResult(
+                    false, jv, expectedType, "entryNotFound", RpcEntryNotFound, "Entry not found.");
                 BEAST_EXPECTS(jv[jss::result][jss::index] == badKey, to_string(jv));
             }
 
@@ -2683,7 +2762,13 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 params[jss::index] = field;
                 params[jss::api_version] = 2;
                 auto const jv = env.rpc("json", "ledger_entry", to_string(params));
-                checkResult(false, jv, expectedType, "malformedRequest");
+                checkResult(
+                    false,
+                    jv,
+                    expectedType,
+                    "malformedRequest",
+                    RpcInvalidParams,
+                    rpc::expectedFieldMessage(jss::index, "hex string"));
                 BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
             }
 
@@ -2722,7 +2807,13 @@ class LedgerEntry_test : public beast::unit_test::Suite
                 params[jss::index] = field;
                 params[jss::api_version] = 2;
                 auto const jv = env.rpc("json", "ledger_entry", to_string(params));
-                checkResult(false, jv, expectedType, "malformedRequest");
+                checkResult(
+                    false,
+                    jv,
+                    expectedType,
+                    "malformedRequest",
+                    RpcInvalidParams,
+                    rpc::expectedFieldMessage(jss::index, "hex string"));
                 BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
             }
 
@@ -2787,7 +2878,9 @@ class LedgerEntry_test : public beast::unit_test::Suite
         auto checkResult = [&](bool good,
                                json::Value const& jv,
                                int expectedCount,
-                               std::optional<std::string> const& expectedError = {}) {
+                               std::optional<std::string> const& expectedError = {},
+                               ErrorCodeI expectedCode = RpcEntryNotFound,
+                               std::string const& expectedMessage = "Entry not found.") {
             if (good)
             {
                 BEAST_EXPECTS(
@@ -2807,9 +2900,10 @@ class LedgerEntry_test : public beast::unit_test::Suite
             {
                 BEAST_EXPECTS(
                     jv.isObject() && jv.isMember(jss::result) &&
-                        jv[jss::result].isMember(jss::error) &&
                         !jv[jss::result].isMember(jss::node) &&
-                        jv[jss::result][jss::error] == expectedError.value_or("entryNotFound"),
+                        jv[jss::result][jss::error] == expectedError.value_or("entryNotFound") &&
+                        jv[jss::result][jss::error_code] == expectedCode &&
+                        jv[jss::result][jss::error_message] == expectedMessage,
                     to_string(jv));
             }
         };
@@ -2839,7 +2933,13 @@ class LedgerEntry_test : public beast::unit_test::Suite
                     params[jss::ledger_index] = jss::validated;
                     params[jss::hashes] = json::ValueType::Null;
                     auto jv = env.rpc("json", "ledger_entry", to_string(params));
-                    checkResult(false, jv, 0, "malformedRequest");
+                    checkResult(
+                        false,
+                        jv,
+                        0,
+                        "malformedRequest",
+                        RpcInvalidParams,
+                        rpc::expectedFieldMessage(jss::hashes, "hex string"));
                     BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
                 }
 
@@ -2849,7 +2949,13 @@ class LedgerEntry_test : public beast::unit_test::Suite
                     params[jss::ledger_index] = jss::validated;
                     params[jss::hashes] = "arbitrary string";
                     auto const jv = env.rpc("json", "ledger_entry", to_string(params));
-                    checkResult(false, jv, 0, "malformedRequest");
+                    checkResult(
+                        false,
+                        jv,
+                        0,
+                        "malformedRequest",
+                        RpcInvalidParams,
+                        rpc::expectedFieldMessage(jss::hashes, "hex string"));
                     BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
                 }
 
@@ -2859,7 +2965,13 @@ class LedgerEntry_test : public beast::unit_test::Suite
                     params[jss::ledger_index] = jss::validated;
                     params[jss::hashes] = "10";
                     auto const jv = env.rpc("json", "ledger_entry", to_string(params));
-                    checkResult(false, jv, 0, "malformedRequest");
+                    checkResult(
+                        false,
+                        jv,
+                        0,
+                        "malformedRequest",
+                        RpcInvalidParams,
+                        rpc::expectedFieldMessage(jss::hashes, "hex string"));
                     BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
                 }
 
@@ -2869,7 +2981,13 @@ class LedgerEntry_test : public beast::unit_test::Suite
                     params[jss::ledger_index] = jss::validated;
                     params[jss::hashes] = false;
                     auto const jv = env.rpc("json", "ledger_entry", to_string(params));
-                    checkResult(false, jv, 0, "invalidParams");
+                    checkResult(
+                        false,
+                        jv,
+                        0,
+                        "invalidParams",
+                        RpcInvalidParams,
+                        rpc::expectedFieldMessage(jss::hashes, "true"));
                     BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
                 }
 
@@ -2879,7 +2997,7 @@ class LedgerEntry_test : public beast::unit_test::Suite
                     params[jss::ledger_index] = jss::validated;
                     params[jss::hashes] = -1;
                     auto const jv = env.rpc("json", "ledger_entry", to_string(params));
-                    checkResult(false, jv, 0, "internal");
+                    checkResult(false, jv, 0, "internal", RpcInternal, "Internal error.");
                     BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
                 }
 
@@ -2890,7 +3008,8 @@ class LedgerEntry_test : public beast::unit_test::Suite
                     params[jss::ledger_index] = jss::validated;
                     params[jss::hashes] = badKey;
                     auto const jv = env.rpc("json", "ledger_entry", to_string(params));
-                    checkResult(false, jv, 0, "entryNotFound");
+                    checkResult(
+                        false, jv, 0, "entryNotFound", RpcEntryNotFound, "Entry not found.");
                     BEAST_EXPECT(jv[jss::result][jss::index] == badKey);
                 }
 
@@ -3028,12 +3147,18 @@ class LedgerEntry_XChain_test : public beast::unit_test::Suite,
                                 public test::jtx::XChainBridgeObjects
 {
     void
-    checkErrorValue(json::Value const& jv, std::string const& err, std::string const& msg)
+    checkErrorValue(
+        json::Value const& jv,
+        std::string const& err,
+        ErrorCodeI code,
+        std::string const& msg)
     {
         if (BEAST_EXPECT(jv.isMember(jss::status)))
             BEAST_EXPECT(jv[jss::status] == "error");
         if (BEAST_EXPECT(jv.isMember(jss::error)))
             BEAST_EXPECT(jv[jss::error] == err);
+        if (BEAST_EXPECT(jv.isMember(jss::error_code)))
+            BEAST_EXPECT(jv[jss::error_code] == code);
         if (msg.empty())
         {
             BEAST_EXPECT(
@@ -3110,7 +3235,7 @@ class LedgerEntry_XChain_test : public beast::unit_test::Suite,
             json::Value const jrr =
                 mcEnv.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
 
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
         {
             // create two claim ids and verify that the bridge counter was
@@ -3297,7 +3422,7 @@ class LedgerEntry_XChain_test : public beast::unit_test::Suite,
                     [jss::xchain_owned_create_account_claim_id] = 1;
             json::Value const jrr =
                 scEnv.rpc("json", "ledger_entry", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "entryNotFound", "Entry not found.");
+            checkErrorValue(jrr, "entryNotFound", RpcEntryNotFound, "Entry not found.");
         }
     }
 

src/test/rpc/LedgerHeader_test.cpp

@@ -3,6 +3,7 @@
 
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_value.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/jss.h>
 
 namespace xrpl {
@@ -53,8 +54,10 @@ class LedgerHeader_test : public beast::unit_test::Suite
         json::Value params{json::ValueType::Object};
         params[jss::api_version] = 2;
         auto const result = env.client().invoke("ledger_header", params)[jss::result];
-        BEAST_EXPECT(result[jss::error] == "unknownCmd");
         BEAST_EXPECT(result[jss::status] == "error");
+        BEAST_EXPECT(result[jss::error] == "unknownCmd");
+        BEAST_EXPECT(result[jss::error_code] == RpcUnknownCommand);
+        BEAST_EXPECT(result[jss::error_message] == "Unknown method.");
     }
 
 public:

src/test/rpc/LedgerRPC_test.cpp

@@ -37,12 +37,18 @@ namespace xrpl::test {
 class LedgerRPC_test : public beast::unit_test::Suite
 {
     void
-    checkErrorValue(json::Value const& jv, std::string const& err, std::string const& msg)
+    checkErrorValue(
+        json::Value const& jv,
+        std::string const& err,
+        ErrorCodeI code,
+        std::string const& msg)
     {
         if (BEAST_EXPECT(jv.isMember(jss::status)))
             BEAST_EXPECT(jv[jss::status] == "error");
         if (BEAST_EXPECT(jv.isMember(jss::error)))
             BEAST_EXPECT(jv[jss::error] == err);
+        if (BEAST_EXPECT(jv.isMember(jss::error_code)))
+            BEAST_EXPECT(jv[jss::error_code] == code);
         if (msg.empty())
         {
             BEAST_EXPECT(
@@ -139,7 +145,10 @@ class LedgerRPC_test : public beast::unit_test::Suite
             jvParams[jss::ledger_index] = "potato";
             auto const jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
             checkErrorValue(
-                jrr, "invalidParams", "Invalid field 'ledger_index', not string or number.");
+                jrr,
+                "invalidParams",
+                RpcInvalidParams,
+                "Invalid field 'ledger_index', not string or number.");
         }
 
         {
@@ -148,7 +157,10 @@ class LedgerRPC_test : public beast::unit_test::Suite
             jvParams[jss::ledger_index] = -1;
             auto const jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
             checkErrorValue(
-                jrr, "invalidParams", "Invalid field 'ledger_index', not string or number.");
+                jrr,
+                "invalidParams",
+                RpcInvalidParams,
+                "Invalid field 'ledger_index', not string or number.");
         }
 
         {
@@ -156,13 +168,13 @@ class LedgerRPC_test : public beast::unit_test::Suite
             json::Value jvParams;
             jvParams[jss::ledger_index] = 10u;
             auto const jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "lgrNotFound", "ledgerNotFound");
+            checkErrorValue(jrr, "lgrNotFound", RpcLgrNotFound, "ledgerNotFound");
         }
 
         {
             // unrecognized string arg -- error
             auto const jrr = env.rpc("ledger", "arbitrary_text")[jss::result];
-            checkErrorValue(jrr, "lgrNotFound", "ledgerNotFound");
+            checkErrorValue(jrr, "lgrNotFound", RpcLgrNotFound, "ledgerNotFound");
         }
 
         {
@@ -171,20 +183,21 @@ class LedgerRPC_test : public beast::unit_test::Suite
             jvParams[jss::ledger_index] = "validated";
             jvParams[jss::queue] = true;
             auto const jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
-            checkErrorValue(jrr, "invalidParams", "Invalid parameters.");
+            checkErrorValue(jrr, "invalidParams", RpcInvalidParams, "Invalid parameters.");
         }
 
         {
             // Request a ledger with a very large (double) sequence.
             auto const ret = env.rpc("json", "ledger", "{ \"ledger_index\" : 2e15 }");
-            BEAST_EXPECT(rpc::containsError(ret));
+            BEAST_EXPECT(ret[jss::error] == "invalidParams");
+            BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(ret[jss::error_message] == "Invalid parameters.");
         }
 
         {
             // Request a ledger with very large (integer) sequence.
             auto const ret = env.rpc("json", "ledger", "{ \"ledger_index\" : 1000000000000000 }");
-            checkErrorValue(ret, "invalidParams", "Invalid parameters.");
+            checkErrorValue(ret, "invalidParams", RpcInvalidParams, "Invalid parameters.");
         }
 
         {
@@ -193,7 +206,7 @@ class LedgerRPC_test : public beast::unit_test::Suite
                 json::Value jvParams;
                 jvParams[field] = "blah";
                 auto const jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
-                checkErrorValue(jrr, "invalidParams", "Invalid parameters.");
+                checkErrorValue(jrr, "invalidParams", RpcInvalidParams, "Invalid parameters.");
             };
             testBooleanField(jss::full);
             testBooleanField(jss::accounts);
@@ -255,7 +268,8 @@ class LedgerRPC_test : public beast::unit_test::Suite
         jvParams[jss::ledger_index] = 1u;
         jvParams[jss::full] = true;
         auto const jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
-        checkErrorValue(jrr, "noPermission", "You don't have permission for this command.");
+        checkErrorValue(
+            jrr, "noPermission", RpcNoPermission, "You don't have permission for this command.");
     }
 
     void
@@ -422,6 +436,7 @@ class LedgerRPC_test : public beast::unit_test::Suite
             jvParams[jss::ledger] = "invalid";
             jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 jrr[jss::error_message] == "Invalid field 'ledger', not string or number.");
 
@@ -436,6 +451,7 @@ class LedgerRPC_test : public beast::unit_test::Suite
             jvParams[jss::ledger] = 20;
             jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "lgrNotFound");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcLgrNotFound);
             BEAST_EXPECT(jrr[jss::error_message] == "ledgerNotFound");
         }
 
@@ -455,12 +471,14 @@ class LedgerRPC_test : public beast::unit_test::Suite
             jvParams[jss::ledger_hash] = "DEADBEEF" + hash3;
             jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'ledger_hash', not hex string.");
 
             // request with non-string ledger_hash
             jvParams[jss::ledger_hash] = 2;
             jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'ledger_hash', not hex string.");
 
             // malformed (non hex) hash
@@ -469,6 +487,7 @@ class LedgerRPC_test : public beast::unit_test::Suite
                 "7F2775F2F7485BB37307984C3C0F2340";
             jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'ledger_hash', not hex string.");
 
             // properly formed, but just doesn't exist
@@ -477,6 +496,7 @@ class LedgerRPC_test : public beast::unit_test::Suite
                 "5A75FD71FC3FD6F36FEB803C5F1D812D";
             jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "lgrNotFound");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcLgrNotFound);
             BEAST_EXPECT(jrr[jss::error_message] == "ledgerNotFound");
         }
 
@@ -506,6 +526,7 @@ class LedgerRPC_test : public beast::unit_test::Suite
             jvParams[jss::ledger_index] = "invalid";
             jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 jrr[jss::error_message] == "Invalid field 'ledger_index', not string or number.");
 
@@ -524,6 +545,7 @@ class LedgerRPC_test : public beast::unit_test::Suite
             jvParams[jss::ledger_index] = 7;
             jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
             BEAST_EXPECT(jrr[jss::error] == "lgrNotFound");
+            BEAST_EXPECT(jrr[jss::error_code] == RpcLgrNotFound);
             BEAST_EXPECT(jrr[jss::error_message] == "ledgerNotFound");
         }
     }

src/test/rpc/LedgerRequest_test.cpp

@@ -43,21 +43,24 @@ public:
             // arbitrary text is converted to 0.
             auto const result = env.rpc("ledger_request", "arbitrary_text");
             BEAST_EXPECT(
-                rpc::containsError(result[jss::result]) &&
+                result[jss::result][jss::error] == "invalidParams" &&
+                result[jss::result][jss::error_code] == RpcInvalidParams &&
                 result[jss::result][jss::error_message] == "Ledger index too small");
         }
 
         {
             auto const result = env.rpc("ledger_request", "-1");
             BEAST_EXPECT(
-                rpc::containsError(result[jss::result]) &&
+                result[jss::result][jss::error] == "invalidParams" &&
+                result[jss::result][jss::error_code] == RpcInvalidParams &&
                 result[jss::result][jss::error_message] == "Ledger index too small");
         }
 
         {
             auto const result = env.rpc("ledger_request", "0");
             BEAST_EXPECT(
-                rpc::containsError(result[jss::result]) &&
+                result[jss::result][jss::error] == "invalidParams" &&
+                result[jss::result][jss::error_code] == RpcInvalidParams &&
                 result[jss::result][jss::error_message] == "Ledger index too small");
         }
 
@@ -112,7 +115,8 @@ public:
             auto const result = env.rpc("ledger_request", ledgerHash);
 
             BEAST_EXPECT(
-                rpc::containsError(result[jss::result]) &&
+                result[jss::result][jss::error] == "invalidParams" &&
+                result[jss::result][jss::error_code] == RpcInvalidParams &&
                 result[jss::result][jss::error_message] ==
                     "Invalid field 'ledger_hash', not hex string.");
         }
@@ -130,14 +134,16 @@ public:
         {
             auto const result = env.rpc("ledger_request", "4");
             BEAST_EXPECT(
-                rpc::containsError(result[jss::result]) &&
+                result[jss::result][jss::error] == "invalidParams" &&
+                result[jss::result][jss::error_code] == RpcInvalidParams &&
                 result[jss::result][jss::error_message] == "Ledger index too large");
         }
 
         {
             auto const result = env.rpc("ledger_request", "5");
             BEAST_EXPECT(
-                rpc::containsError(result[jss::result]) &&
+                result[jss::result][jss::error] == "invalidParams" &&
+                result[jss::result][jss::error_code] == RpcInvalidParams &&
                 result[jss::result][jss::error_message] == "Ledger index too large");
         }
     }
@@ -236,8 +242,9 @@ public:
             "8FE8592EF22FBC2E8C774C7A1ED76AA3FCE64BED17D748CBA9AFDF7072FE36C7");
 
         result = env.rpc("ledger_request", "6")[jss::result];
-        BEAST_EXPECT(result[jss::error] == "invalidParams");
         BEAST_EXPECT(result[jss::status] == "error");
+        BEAST_EXPECT(result[jss::error] == "invalidParams");
+        BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
         BEAST_EXPECT(result[jss::error_message] == "Ledger index too large");
     }
 
@@ -259,8 +266,9 @@ public:
             jvParams[jss::ledger_index] = "1";
             auto const result =
                 env.rpc("json", "ledger_request", jvParams.toStyledString())[jss::result];
-            BEAST_EXPECT(result[jss::error] == "invalidParams");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 result[jss::error_message] ==
                 "Exactly one of 'ledger_hash' or 'ledger_index' can be "
@@ -272,8 +280,9 @@ public:
             jvParams[jss::ledger_index] = "index";
             auto const result =
                 env.rpc("json", "ledger_request", jvParams.toStyledString())[jss::result];
-            BEAST_EXPECT(result[jss::error] == "invalidParams");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Invalid field 'ledger_index', not number.");
         }
 
@@ -285,11 +294,13 @@ public:
         if (apiVersion == 1)
         {
             BEAST_EXPECT(result[jss::error] == "noCurrent");
+            BEAST_EXPECT(result[jss::error_code] == RpcNoCurrent);
             BEAST_EXPECT(result[jss::error_message] == "Current ledger is unavailable.");
         }
         else
         {
             BEAST_EXPECT(result[jss::error] == "notSynced");
+            BEAST_EXPECT(result[jss::error_code] == RpcNotSynced);
             BEAST_EXPECT(result[jss::error_message] == "Not synced to the network.");
         }
     }

src/test/rpc/ManifestRPC_test.cpp

@@ -7,6 +7,7 @@
 
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/config/Constants.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/jss.h>
 
 #include <memory>
@@ -27,6 +28,8 @@ public:
         {
             // manifest with no public key
             auto const info = env.rpc("json", "manifest", "{ }");
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(info[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(info[jss::result][jss::error_message] == "Missing field 'public_key'.");
         }
         {
@@ -36,6 +39,8 @@ public:
                 "manifest",
                 "{ \"public_key\": "
                 "\"abcdef12345\"}");
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(info[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(info[jss::result][jss::error_message] == "Invalid parameters.");
         }
     }

src/test/rpc/NoRippleCheck_test.cpp

@@ -19,6 +19,7 @@
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/SecretKey.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/jss.h>
@@ -49,6 +50,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite
         {  // missing account field
             auto const result = env.rpc("json", "noripple_check", "{}")[jss::result];
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Missing field 'account'.");
         }
 
@@ -57,6 +59,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite
             params[jss::account] = alice.human();
             auto const result = env.rpc("json", "noripple_check", to_string(params))[jss::result];
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Missing field 'role'.");
         }
 
@@ -68,6 +71,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite
                 params[jss::role] = "user";
                 auto jrr = env.rpc("json", "noripple_check", to_string(params))[jss::result];
                 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+                BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
                 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'account'.");
             };
 
@@ -85,6 +89,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite
             params[jss::role] = "not_a_role";
             auto const result = env.rpc("json", "noripple_check", to_string(params))[jss::result];
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Invalid field 'role'.");
         }
 
@@ -95,6 +100,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite
             params[jss::limit] = -1;
             auto const result = env.rpc("json", "noripple_check", to_string(params))[jss::result];
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 result[jss::error_message] == "Invalid field 'limit', not unsigned integer.");
         }
@@ -106,6 +112,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite
             params[jss::ledger_hash] = 1;
             auto const result = env.rpc("json", "noripple_check", to_string(params))[jss::result];
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 result[jss::error_message] == "Invalid field 'ledger_hash', not hex string.");
         }
@@ -117,6 +124,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite
             params[jss::ledger] = "current";
             auto const result = env.rpc("json", "noripple_check", to_string(params))[jss::result];
             BEAST_EXPECT(result[jss::error] == "actNotFound");
+            BEAST_EXPECT(result[jss::error_code] == RpcActNotFound);
             BEAST_EXPECT(result[jss::error_message] == "Account not found.");
         }
 
@@ -129,6 +137,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite
             params[jss::transactions] = true;
             auto const result = env.rpc("json", "noripple_check", to_string(params))[jss::result];
             BEAST_EXPECT(result[jss::error] == "actMalformed");
+            BEAST_EXPECT(result[jss::error_code] == RpcActMalformed);
             BEAST_EXPECT(result[jss::error_message] == "Account malformed.");
             // The changelog promises malformed-account responses carry
             // neither `transactions` nor any ledger metadata.
@@ -147,6 +156,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite
             params[jss::ledger_hash] = "ABCDEF";
             auto const result = env.rpc("json", "noripple_check", to_string(params))[jss::result];
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 result[jss::error_message] ==
                 "Exactly one of 'ledger', 'ledger_hash', or 'ledger_index' can "
@@ -161,6 +171,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite
             params[jss::ledger] = json::ValueType::Object;
             auto const result = env.rpc("json", "noripple_check", to_string(params))[jss::result];
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 result[jss::error_message] == "Invalid field 'ledger', not string or number.");
         }

src/test/rpc/NoRipple_test.cpp

@@ -14,6 +14,7 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
 #include <xrpl/protocol/ApiVersion.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
@@ -256,6 +257,9 @@ public:
                 else
                 {
                     BEAST_EXPECT(lines[jss::result][jss::error] == "invalidParams");
+                    BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcInvalidParams);
+                    BEAST_EXPECT(
+                        lines[jss::result][jss::error_message] == "Invalid field 'transactions'.");
                 }
             }
         }

src/test/rpc/OwnerInfo_test.cpp

@@ -10,6 +10,7 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/UintTypes.h>
@@ -34,6 +35,7 @@ class OwnerInfo_test : public beast::unit_test::Suite
         {  // missing account field
             auto const result = env.rpc("json", "owner_info", "{}")[jss::result];
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Missing field 'account'.");
         }
 
@@ -44,8 +46,10 @@ class OwnerInfo_test : public beast::unit_test::Suite
             if (BEAST_EXPECT(result.isMember(jss::accepted) && result.isMember(jss::current)))
             {
                 BEAST_EXPECT(result[jss::accepted][jss::error] == "actMalformed");
+                BEAST_EXPECT(result[jss::accepted][jss::error_code] == RpcActMalformed);
                 BEAST_EXPECT(result[jss::accepted][jss::error_message] == "Account malformed.");
                 BEAST_EXPECT(result[jss::current][jss::error] == "actMalformed");
+                BEAST_EXPECT(result[jss::current][jss::error_code] == RpcActMalformed);
                 BEAST_EXPECT(result[jss::current][jss::error_message] == "Account malformed.");
             }
         }

src/test/rpc/Simulate_test.cpp

@@ -183,6 +183,8 @@ class Simulate_test : public beast::unit_test::Suite
             // No params
             json::Value const params = json::ValueType::Object;
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] ==
                 "Neither `tx_blob` nor `tx_json` included.");
@@ -194,6 +196,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_blob] = "1200";
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] ==
                 "Can only include one of `tx_blob` and `tx_json`.");
@@ -204,6 +208,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_blob] = "1200";
             params[jss::binary] = "100";
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'binary'.");
         }
         {
@@ -212,6 +218,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_blob] = "12";
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx_blob'.");
         }
         {
@@ -220,6 +228,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = json::ValueType::Object;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] == "Missing field 'tx.TransactionType'.");
         }
@@ -231,6 +241,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = txJson;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Missing field 'tx.Account'.");
         }
         {
@@ -239,6 +251,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_blob] = "";
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx_blob'.");
         }
         {
@@ -247,6 +261,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_blob] = 1.1;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx_blob'.");
         }
         {
@@ -255,6 +271,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = "";
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] == "Invalid field 'tx_json', not object.");
         }
@@ -267,6 +285,8 @@ class Simulate_test : public beast::unit_test::Suite
             txJson[jss::Account] = env.master.human();
             params[jss::tx_json] = txJson;
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'seed'.");
         }
         {
@@ -278,6 +298,8 @@ class Simulate_test : public beast::unit_test::Suite
             txJson[jss::Account] = env.master.human();
             params[jss::tx_json] = txJson;
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'secret'.");
         }
         {
@@ -289,6 +311,8 @@ class Simulate_test : public beast::unit_test::Suite
             txJson[jss::Account] = env.master.human();
             params[jss::tx_json] = txJson;
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'seed_hex'.");
         }
         {
@@ -300,6 +324,8 @@ class Simulate_test : public beast::unit_test::Suite
             txJson[jss::Account] = env.master.human();
             params[jss::tx_json] = txJson;
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'passphrase'.");
         }
         {
@@ -311,6 +337,9 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = txJson;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidTransaction");
+            BEAST_EXPECT(!resp[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(resp[jss::result][jss::error_message].isNull());
             BEAST_EXPECT(
                 resp[jss::result][jss::error_exception] ==
                 "Field 'Destination' is required but missing.");
@@ -327,6 +356,7 @@ class Simulate_test : public beast::unit_test::Suite
             BEAST_EXPECTS(
                 resp[jss::result][jss::error] == "srcActMalformed",
                 resp[jss::result][jss::error].toStyledString());
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcSrcActMalformed);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx.Account'.");
         }
         {
@@ -338,6 +368,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = txJson;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "srcActNotFound");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcSrcActNotFound);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Source account not found.");
         }
         {
@@ -350,6 +382,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = txJson;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx.Signers'.");
         }
         {
@@ -363,6 +397,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = txJson;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Invalid field 'tx.Signers[0]'.");
         }
         {
@@ -375,6 +411,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = txJson;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] ==
                 "Invalid field 'SponsorSignature', not object.");
@@ -391,6 +429,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = txJson;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECTS(
                 resp[jss::result][jss::error_message] ==
                     "Invalid field 'tx.SponsorSignature.Signers'.",
@@ -406,6 +446,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = txJson;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] == "Field 'tx_json.foo' is unknown.");
         }
@@ -415,6 +457,8 @@ class Simulate_test : public beast::unit_test::Suite
             txJson[jss::TransactionType] = jss::AccountSet;
             txJson[jss::Account] = alice.human();
             auto const resp = env.rpc("simulate", to_string(txJson), "1");
+            BEAST_EXPECT(resp[jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(resp[jss::error_message] == "Invalid parameters.");
         }
         {
@@ -427,6 +471,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = txJson;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "transactionSigned");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcTxSigned);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] == "Transaction should not be signed.");
         }
@@ -449,6 +495,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = txJson;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "transactionSigned");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcTxSigned);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] == "Transaction should not be signed.");
         }
@@ -462,6 +510,8 @@ class Simulate_test : public beast::unit_test::Suite
             params[jss::tx_json] = txJson;
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
+            BEAST_EXPECT(resp[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(
                 resp[jss::result][jss::error_message] ==
                 "tfInnerBatchTxn flag is not allowed on top-level transactions.");
@@ -530,6 +580,7 @@ class Simulate_test : public beast::unit_test::Suite
             {
                 auto const resp = simulate(env, tx);
                 BEAST_EXPECT(resp[jss::error] == "noPermission");
+                BEAST_EXPECT(resp[jss::error_code] == RpcNoPermission);
                 BEAST_EXPECT(
                     resp[jss::error_message] ==
                     "WASM transactions are only supported in admin mode.");
@@ -559,7 +610,10 @@ class Simulate_test : public beast::unit_test::Suite
 
         using namespace jtx;
 
+        // Pin the reference fee so the asserted error message doesn't depend on
+        // UNIT_TEST_REFERENCE_FEE.
         Env env(*this, envconfig([](std::unique_ptr<Config> cfg) {
+            cfg->fees.referenceFee = 10;
             cfg->section(Sections::kTransactionQueue).set(Keys::kMinimumTxnInLedgerStandalone, "3");
             return cfg;
         }));
@@ -579,11 +633,10 @@ class Simulate_test : public beast::unit_test::Suite
 
             auto const resp = env.rpc("json", "simulate", to_string(params));
             auto const result = resp[jss::result];
-            if (BEAST_EXPECT(result.isMember(jss::error)))
-            {
-                BEAST_EXPECT(result[jss::error] == "highFee");
-                BEAST_EXPECT(result[jss::error_code] == RpcHighFee);
-            }
+            BEAST_EXPECT(result[jss::error] == "highFee");
+            BEAST_EXPECT(result[jss::error_code] == RpcHighFee);
+            BEAST_EXPECT(
+                result[jss::error_message] == "Fee of 8889 exceeds the requested tx limit of 100");
         }
     }
 
@@ -613,6 +666,7 @@ class Simulate_test : public beast::unit_test::Suite
         params[jss::tx_json] = jt.jv;
         auto const resp = env.rpc("json", "simulate", to_string(params));
         BEAST_EXPECT(resp[jss::result][jss::error] == "notImpl");
+        BEAST_EXPECT(resp[jss::result][jss::error_code] == RpcNotImpl);
         BEAST_EXPECT(resp[jss::result][jss::error_message] == "Not implemented.");
     }
 

src/test/rpc/Submit_test.cpp

@@ -8,6 +8,7 @@
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Seed.h>
 #include <xrpl/protocol/jss.h>
 
@@ -39,6 +40,7 @@ public:
                 params[jss::fail_hard] = param;
                 auto const jrr = env.rpc("json", "submit", to_string(params))[jss::result];
                 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+                BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
                 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'fail_hard', not boolean.");
             }
 
@@ -50,6 +52,7 @@ public:
                 params[jss::fail_hard] = param;
                 auto const jrr = env.rpc("json", "submit", to_string(params))[jss::result];
                 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+                BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
                 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'fail_hard', not boolean.");
             }
         };

src/test/rpc/Subscribe_test.cpp

@@ -31,6 +31,7 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Fees.h>
 #include <xrpl/protocol/Indexes.h>
@@ -621,6 +622,7 @@ public:
         {
             auto const jr = env.rpc("json", method, "{}")[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
         }
 
@@ -633,6 +635,7 @@ public:
             if (subscribe)
             {
                 BEAST_EXPECT(jr[jss::error] == "invalidParams");
+                BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
                 BEAST_EXPECT(jr[jss::error_message] == "Failed to parse url.");
             }
             // else TODO: why isn't this an error for unsubscribe ?
@@ -646,6 +649,7 @@ public:
             if (subscribe)
             {
                 BEAST_EXPECT(jr[jss::error] == "invalidParams");
+                BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
                 BEAST_EXPECT(jr[jss::error_message] == "Only http and https is supported.");
             }
         }
@@ -656,6 +660,7 @@ public:
             jv[jss::url] = "no-url";
             auto const jr = envNonadmin.rpc("json", method, to_string(jv))[jss::result];
             BEAST_EXPECT(jr[jss::error] == "noPermission");
+            BEAST_EXPECT(jr[jss::error_code] == RpcNoPermission);
             BEAST_EXPECT(jr[jss::error_message] == "You don't have permission for this command.");
         }
 
@@ -677,6 +682,7 @@ public:
                 jv[f] = nonArray;
                 auto const jr = wsc->invoke(method, jv)[jss::result];
                 BEAST_EXPECT(jr[jss::error] == "invalidParams");
+                BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
                 BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
             }
 
@@ -685,6 +691,7 @@ public:
                 jv[f] = json::ValueType::Array;
                 auto const jr = wsc->invoke(method, jv)[jss::result];
                 BEAST_EXPECT(jr[jss::error] == "actMalformed");
+                BEAST_EXPECT(jr[jss::error_code] == RpcActMalformed);
                 BEAST_EXPECT(jr[jss::error_message] == "Account malformed.");
             }
         }
@@ -695,6 +702,7 @@ public:
             jv[jss::mpt_issuances] = nonArray;
             auto jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
         }
 
@@ -704,6 +712,7 @@ public:
             jv[jss::mpt_issuances][0u] = 1;
             auto jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
         }
 
@@ -713,6 +722,7 @@ public:
             jv[jss::mpt_issuances][0u] = "not-an-mpt-issuance-id";
             auto jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
         }
 
@@ -722,6 +732,7 @@ public:
             jv[jss::mpt_issuances][0u] = "0123456789ABCDEF";
             auto jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
         }
 
@@ -731,6 +742,7 @@ public:
             jv[jss::books] = nonArray;
             auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
         }
 
@@ -740,6 +752,7 @@ public:
             jv[jss::books][0u] = 1;
             auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
         }
 
@@ -752,6 +765,7 @@ public:
             auto const jr = wsc->invoke(method, jv)[jss::result];
 
             BEAST_EXPECT(jr[jss::error] == "srcCurMalformed");
+            BEAST_EXPECT(jr[jss::error_code] == RpcSrcCurMalformed);
             BEAST_EXPECT(jr[jss::error_message] == "Source currency is malformed.");
         }
 
@@ -764,6 +778,7 @@ public:
             jv[jss::books][0u][jss::taker_pays][jss::currency] = "ZZZZ";
             auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "srcCurMalformed");
+            BEAST_EXPECT(jr[jss::error_code] == RpcSrcCurMalformed);
             BEAST_EXPECT(jr[jss::error_message] == "Source currency is malformed.");
         }
 
@@ -777,6 +792,7 @@ public:
             jv[jss::books][0u][jss::taker_pays][jss::issuer] = 1;
             auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "srcIsrMalformed");
+            BEAST_EXPECT(jr[jss::error_code] == RpcSrcIsrMalformed);
             BEAST_EXPECT(jr[jss::error_message] == "Source issuer is malformed.");
         }
 
@@ -790,6 +806,7 @@ public:
             jv[jss::books][0u][jss::taker_pays][jss::issuer] = Account{"gateway"}.human() + "DEAD";
             auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "srcIsrMalformed");
+            BEAST_EXPECT(jr[jss::error_code] == RpcSrcIsrMalformed);
             BEAST_EXPECT(jr[jss::error_message] == "Source issuer is malformed.");
         }
 
@@ -803,6 +820,7 @@ public:
             auto const jr = wsc->invoke(method, jv)[jss::result];
             // NOTE: this error is slightly incongruous with the equivalent source currency error
             BEAST_EXPECT(jr[jss::error] == "dstAmtMalformed");
+            BEAST_EXPECT(jr[jss::error_code] == RpcDstAmtMalformed);
             BEAST_EXPECT(
                 jr[jss::error_message] == "Destination amount/currency/issuer is malformed.");
         }
@@ -818,6 +836,7 @@ public:
             // NOTE: this error is slightly incongruous with the
             // equivalent source currency error
             BEAST_EXPECT(jr[jss::error] == "dstAmtMalformed");
+            BEAST_EXPECT(jr[jss::error_code] == RpcDstAmtMalformed);
             BEAST_EXPECT(
                 jr[jss::error_message] == "Destination amount/currency/issuer is malformed.");
         }
@@ -832,6 +851,7 @@ public:
             jv[jss::books][0u][jss::taker_gets][jss::issuer] = 1;
             auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "dstIsrMalformed");
+            BEAST_EXPECT(jr[jss::error_code] == RpcDstIsrMalformed);
             BEAST_EXPECT(jr[jss::error_message] == "Destination issuer is malformed.");
         }
 
@@ -845,6 +865,7 @@ public:
             jv[jss::books][0u][jss::taker_gets][jss::issuer] = Account{"gateway"}.human() + "DEAD";
             auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "dstIsrMalformed");
+            BEAST_EXPECT(jr[jss::error_code] == RpcDstIsrMalformed);
             BEAST_EXPECT(jr[jss::error_message] == "Destination issuer is malformed.");
         }
 
@@ -858,6 +879,7 @@ public:
                 Account{"gateway"}["USD"](1).value().getJson(JsonOptions::Values::IncludeDate);
             auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "badMarket");
+            BEAST_EXPECT(jr[jss::error_code] == RpcBadMarket);
             BEAST_EXPECT(jr[jss::error_message] == "No such market.");
         }
 
@@ -867,6 +889,7 @@ public:
             jv[jss::streams] = nonArray;
             auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
         }
 
@@ -876,6 +899,7 @@ public:
             jv[jss::streams][0u] = 1;
             auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "malformedStream");
+            BEAST_EXPECT(jr[jss::error_code] == RpcStreamMalformed);
             BEAST_EXPECT(jr[jss::error_message] == "Stream malformed.");
         }
 
@@ -885,6 +909,7 @@ public:
             jv[jss::streams][0u] = "not_a_stream";
             auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "malformedStream");
+            BEAST_EXPECT(jr[jss::error_code] == RpcStreamMalformed);
             BEAST_EXPECT(jr[jss::error_message] == "Stream malformed.");
         }
 
@@ -901,6 +926,7 @@ public:
                 jv[jss::books][0u][jss::taker] = 1;
                 auto const jr = wsc->invoke(method, jv)[jss::result];
                 BEAST_EXPECTS(jr[jss::error] == "actMalformed", jr.toStyledString());
+                BEAST_EXPECT(jr[jss::error_code] == RpcActMalformed);
                 BEAST_EXPECT(jr[jss::error_message] == "Account malformed.");
             }
 
@@ -915,6 +941,7 @@ public:
                 jv[jss::books][0u][jss::taker] = "not_an_account";
                 auto const jr = wsc->invoke(method, jv)[jss::result];
                 BEAST_EXPECTS(jr[jss::error] == "actMalformed", jr.toStyledString());
+                BEAST_EXPECT(jr[jss::error_code] == RpcActMalformed);
                 BEAST_EXPECT(jr[jss::error_message] == "Account malformed.");
             }
 
@@ -929,6 +956,7 @@ public:
                 jv[jss::books][0u][jss::taker] = Account{"alice"}.human() + "DEAD";
                 auto const jr = wsc->invoke(method, jv)[jss::result];
                 BEAST_EXPECTS(jr[jss::error] == "actMalformed", jr.toStyledString());
+                BEAST_EXPECT(jr[jss::error_code] == RpcActMalformed);
                 BEAST_EXPECT(jr[jss::error_message] == "Account malformed.");
             }
         }
@@ -1784,6 +1812,7 @@ public:
         auto const jr =
             wsc->invoke("subscribe", accountsRequest(makeAccountStrings(6)))[jss::result];
         BEAST_EXPECT(jr[jss::error] == "invalidParams");
+        BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
         BEAST_EXPECT(jr[jss::error_message] == "Too many subscriptions for this connection.");
     }
 
@@ -1866,6 +1895,7 @@ public:
         {
             auto const jr = wsc->invoke("subscribe", req)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Too many subscriptions for this connection.");
         }
 
@@ -1916,6 +1946,7 @@ public:
             auto const jr =
                 wsc->invoke("subscribe", accountHistoryRequest(alice.human()))[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
             BEAST_EXPECT(jr[jss::error_message] != "Too many subscriptions for this connection.");
         }
@@ -1951,6 +1982,7 @@ public:
             auto const jr =
                 wsc->invoke("subscribe", accountHistoryRequest(bob.human()))[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Too many subscriptions for this connection.");
         }
     }
@@ -1974,6 +2006,7 @@ public:
             auto const jr = wsc->invoke(
                 "subscribe", mptIssuancesRequest(makeMPTIssuanceStrings(6)))[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Too many subscriptions for this connection.");
         }
 
@@ -2017,6 +2050,7 @@ public:
             auto const jr = wsc->invoke(
                 "subscribe", mptIssuancesRequest(makeMPTIssuanceStrings(1, 100)))[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Too many subscriptions for this connection.");
         }
     }
@@ -2041,6 +2075,7 @@ public:
             auto const jr = wsc->invoke(
                 "subscribe", mptIssuancesRequest(makeMPTIssuanceStrings(3)))[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Too many subscriptions for this connection.");
 
             // Two more issuances do fit the remaining allowance.
@@ -2062,6 +2097,7 @@ public:
             auto const jr =
                 wsc->invoke("subscribe", accountsRequest(makeAccountStrings(1)))[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jr[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(jr[jss::error_message] == "Too many subscriptions for this connection.");
         }
     }

src/test/rpc/TransactionEntry_test.cpp

@@ -38,16 +38,20 @@ class TransactionEntry_test : public beast::unit_test::Suite
         {
             // no params
             auto const result = env.client().invoke("transaction_entry", {})[jss::result];
-            BEAST_EXPECT(result[jss::error] == "fieldNotFoundTransaction");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "fieldNotFoundTransaction");
+            BEAST_EXPECT(!result.isMember(jss::error_code));
+            BEAST_EXPECT(result[jss::error_message].isNull());
         }
 
         {
             json::Value params{json::ValueType::Object};
             params[jss::ledger] = 20;
             auto const result = env.client().invoke("transaction_entry", params)[jss::result];
-            BEAST_EXPECT(result[jss::error] == "lgrNotFound");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "lgrNotFound");
+            BEAST_EXPECT(result[jss::error_code] == RpcLgrNotFound);
+            BEAST_EXPECT(result[jss::error_message] == "ledgerNotFound");
         }
 
         {
@@ -55,8 +59,10 @@ class TransactionEntry_test : public beast::unit_test::Suite
             params[jss::ledger] = "current";
             params[jss::tx_hash] = "DEADBEEF";
             auto const result = env.client().invoke("transaction_entry", params)[jss::result];
-            BEAST_EXPECT(result[jss::error] == "notYetImplemented");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "notYetImplemented");
+            BEAST_EXPECT(!result.isMember(jss::error_code));
+            BEAST_EXPECT(result[jss::error_message].isNull());
         }
 
         {
@@ -65,8 +71,10 @@ class TransactionEntry_test : public beast::unit_test::Suite
             params[jss::tx_hash] =
                 "E2FE8D4AF3FCC3944DDF6CD8CDDC5E3F0AD50863EF8919AFEF10CB6408CD4D05";
             auto const result = env.client().invoke("transaction_entry", params)[jss::result];
-            BEAST_EXPECT(result[jss::error] == "notYetImplemented");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "notYetImplemented");
+            BEAST_EXPECT(!result.isMember(jss::error_code));
+            BEAST_EXPECT(result[jss::error_message].isNull());
             BEAST_EXPECT(result.isMember(jss::ledger_current_index));
             BEAST_EXPECT(!result.isMember(jss::ledger_hash));
             BEAST_EXPECT(result[jss::validated] == false);
@@ -78,8 +86,10 @@ class TransactionEntry_test : public beast::unit_test::Suite
             params[jss::tx_hash] = "DEADBEEF";
             auto const result = env.client().invoke("transaction_entry", params)[jss::result];
             BEAST_EXPECT(!result[jss::ledger_hash].asString().empty());
-            BEAST_EXPECT(result[jss::error] == "malformedRequest");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "malformedRequest");
+            BEAST_EXPECT(!result.isMember(jss::error_code));
+            BEAST_EXPECT(result[jss::error_message].isNull());
         }
 
         for (auto const type : {json::ValueType::Object, json::ValueType::Array})
@@ -88,8 +98,10 @@ class TransactionEntry_test : public beast::unit_test::Suite
             params[jss::ledger] = "closed";
             params[jss::tx_hash] = json::Value{type};
             auto const result = env.client().invoke("transaction_entry", params)[jss::result];
-            BEAST_EXPECT(result[jss::error] == "malformedRequest");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "malformedRequest");
+            BEAST_EXPECT(!result.isMember(jss::error_code));
+            BEAST_EXPECT(result[jss::error_message].isNull());
         }
 
         std::string const txHash{
@@ -100,58 +112,74 @@ class TransactionEntry_test : public beast::unit_test::Suite
             // No arguments
             json::Value const result{env.rpc("transaction_entry")};
             BEAST_EXPECT(result[jss::ledger_hash].asString().empty());
-            BEAST_EXPECT(result[jss::error] == "badSyntax");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "badSyntax");
+            BEAST_EXPECT(result[jss::error_code] == RpcBadSyntax);
+            BEAST_EXPECT(result[jss::error_message] == "Syntax error.");
         }
 
         {
             // One argument
             json::Value const result{env.rpc("transaction_entry", txHash)};
-            BEAST_EXPECT(result[jss::error] == "badSyntax");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "badSyntax");
+            BEAST_EXPECT(result[jss::error_code] == RpcBadSyntax);
+            BEAST_EXPECT(result[jss::error_message] == "Syntax error.");
         }
 
         {
             // First argument with too few characters
             json::Value const result{env.rpc("transaction_entry", txHash.substr(1), "closed")};
-            BEAST_EXPECT(result[jss::error] == "invalidParams");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(result[jss::error_message] == "Invalid parameters.");
         }
 
         {
             // First argument with too many characters
             json::Value const result{env.rpc("transaction_entry", txHash + "A", "closed")};
-            BEAST_EXPECT(result[jss::error] == "invalidParams");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(result[jss::error_message] == "Invalid parameters.");
         }
 
         {
             // Second argument not valid
             json::Value const result{env.rpc("transaction_entry", txHash, "closer")};
-            BEAST_EXPECT(result[jss::error] == "invalidParams");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(result[jss::error_message] == "Invalid parameters.");
         }
 
         {
             // Ledger index of 0 is not valid
             json::Value const result{env.rpc("transaction_entry", txHash, "0")};
-            BEAST_EXPECT(result[jss::error] == "invalidParams");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(result[jss::error_message] == "Invalid parameters.");
         }
 
         {
             // Three arguments
             json::Value const result{env.rpc("transaction_entry", txHash, "closed", "extra")};
-            BEAST_EXPECT(result[jss::error] == "badSyntax");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "badSyntax");
+            BEAST_EXPECT(result[jss::error_code] == RpcBadSyntax);
+            BEAST_EXPECT(result[jss::error_message] == "Syntax error.");
         }
 
         {
             // Valid structure, but transaction not found.
             json::Value const result{env.rpc("transaction_entry", txHash, "closed")};
             BEAST_EXPECT(!result[jss::result][jss::ledger_hash].asString().empty());
-            BEAST_EXPECT(result[jss::result][jss::error] == "transactionNotFound");
             BEAST_EXPECT(result[jss::result][jss::status] == "error");
+            BEAST_EXPECT(result[jss::result][jss::error] == "transactionNotFound");
+            BEAST_EXPECT(!result[jss::result].isMember(jss::error_code));
+            BEAST_EXPECT(result[jss::result][jss::error_message].isNull());
         }
     }
 

src/test/rpc/TransactionHistory_test.cpp

@@ -7,6 +7,7 @@
 
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_value.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/jss.h>
 
@@ -30,8 +31,10 @@ class TransactionHistory_test : public beast::unit_test::Suite
         {
             // no params
             auto const result = env.client().invoke("tx_history", {})[jss::result];
-            BEAST_EXPECT(result[jss::error] == "invalidParams");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
+            BEAST_EXPECT(result[jss::error_message] == "Invalid parameters.");
         }
 
         {
@@ -39,8 +42,11 @@ class TransactionHistory_test : public beast::unit_test::Suite
             json::Value params{json::ValueType::Object};
             params[jss::start] = 10001;  // limited to <= 10000 for non admin
             auto const result = env.client().invoke("tx_history", params)[jss::result];
-            BEAST_EXPECT(result[jss::error] == "noPermission");
             BEAST_EXPECT(result[jss::status] == "error");
+            BEAST_EXPECT(result[jss::error] == "noPermission");
+            BEAST_EXPECT(result[jss::error_code] == RpcNoPermission);
+            BEAST_EXPECT(
+                result[jss::error_message] == "You don't have permission for this command.");
         }
     }
 
@@ -54,8 +60,10 @@ class TransactionHistory_test : public beast::unit_test::Suite
         json::Value params{json::ValueType::Object};
         params[jss::api_version] = 2;
         auto const result = env.client().invoke("tx_history", params)[jss::result];
-        BEAST_EXPECT(result[jss::error] == "unknownCmd");
         BEAST_EXPECT(result[jss::status] == "error");
+        BEAST_EXPECT(result[jss::error] == "unknownCmd");
+        BEAST_EXPECT(result[jss::error_code] == RpcUnknownCommand);
+        BEAST_EXPECT(result[jss::error_message] == "Unknown method.");
     }
 
     void

src/test/rpc/Transaction_test.cpp

@@ -110,9 +110,10 @@ class Transaction_test : public beast::unit_test::Suite
                 to_string(startLegSeq),
                 to_string(endLegSeq + deltaEndSeq));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcTxnNotFound);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Transaction not found.");
 
             if (deltaEndSeq != 0)
             {
@@ -153,9 +154,10 @@ class Transaction_test : public beast::unit_test::Suite
                 to_string(startLegSeq),
                 to_string(endLegSeq + deltaEndSeq));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcTxnNotFound);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Transaction not found.");
             BEAST_EXPECT(!result[jss::result][jss::searched_all].asBool());
         }
 
@@ -168,9 +170,10 @@ class Transaction_test : public beast::unit_test::Suite
                 to_string(startLegSeq),
                 to_string(endLegSeq));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcTxnNotFound);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Transaction not found.");
 
             BEAST_EXPECT(!result[jss::result][jss::searched_all].asBool());
         }
@@ -184,9 +187,10 @@ class Transaction_test : public beast::unit_test::Suite
                 to_string(startLegSeq),
                 to_string(deletedLedger - 1));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcTxnNotFound);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Transaction not found.");
 
             BEAST_EXPECT(result[jss::result][jss::searched_all].asBool());
         }
@@ -213,9 +217,10 @@ class Transaction_test : public beast::unit_test::Suite
                 to_string(deletedLedger - 1),
                 to_string(startLegSeq));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcInvalidLgrRange);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Ledger range is invalid.");
 
             BEAST_EXPECT(!result[jss::result].isMember(jss::searched_all));
         }
@@ -229,9 +234,10 @@ class Transaction_test : public beast::unit_test::Suite
                 to_string(-1),
                 to_string(deletedLedger - 1));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcInvalidLgrRange);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Ledger range is invalid.");
 
             BEAST_EXPECT(!result[jss::result].isMember(jss::searched_all));
         }
@@ -241,9 +247,10 @@ class Transaction_test : public beast::unit_test::Suite
             auto const result = env.rpc(
                 command, to_string(tx->getTransactionID()), binary, to_string(-20), to_string(-10));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcInvalidLgrRange);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Ledger range is invalid.");
 
             BEAST_EXPECT(!result[jss::result].isMember(jss::searched_all));
         }
@@ -253,9 +260,10 @@ class Transaction_test : public beast::unit_test::Suite
             auto const result =
                 env.rpc(command, to_string(tx->getTransactionID()), binary, to_string(20));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcInvalidLgrRange);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Ledger range is invalid.");
 
             BEAST_EXPECT(!result[jss::result].isMember(jss::searched_all));
         }
@@ -283,9 +291,10 @@ class Transaction_test : public beast::unit_test::Suite
                 to_string(startLegSeq),
                 to_string(startLegSeq + 1001));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == excessive);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == excessive);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcExcessiveLgrRange);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Ledger range exceeds 1000.");
 
             BEAST_EXPECT(!result[jss::result].isMember(jss::searched_all));
         }
@@ -351,9 +360,10 @@ class Transaction_test : public beast::unit_test::Suite
             auto const result = env.rpc(
                 command, ctid, binary, to_string(startLegSeq), to_string(endLegSeq + deltaEndSeq));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcTxnNotFound);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Transaction not found.");
 
             if (deltaEndSeq != 0)
             {
@@ -394,9 +404,10 @@ class Transaction_test : public beast::unit_test::Suite
             auto const result = env.rpc(
                 command, ctid, binary, to_string(startLegSeq), to_string(endLegSeq + deltaEndSeq));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcTxnNotFound);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Transaction not found.");
             BEAST_EXPECT(!result[jss::result][jss::searched_all].asBool());
         }
 
@@ -406,9 +417,10 @@ class Transaction_test : public beast::unit_test::Suite
             auto const result =
                 env.rpc(command, ctid, to_string(startLegSeq), to_string(endLegSeq));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcTxnNotFound);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Transaction not found.");
 
             BEAST_EXPECT(!result[jss::result][jss::searched_all].asBool());
         }
@@ -419,9 +431,10 @@ class Transaction_test : public beast::unit_test::Suite
             auto const result =
                 env.rpc(command, ctid, to_string(startLegSeq), to_string(deletedLedger - 1));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == notFound);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcTxnNotFound);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Transaction not found.");
 
             BEAST_EXPECT(!result[jss::result][jss::searched_all].asBool());
         }
@@ -447,9 +460,10 @@ class Transaction_test : public beast::unit_test::Suite
             auto const result = env.rpc(
                 command, ctid, binary, to_string(deletedLedger - 1), to_string(startLegSeq));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcInvalidLgrRange);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Ledger range is invalid.");
 
             BEAST_EXPECT(!result[jss::result].isMember(jss::searched_all));
         }
@@ -459,9 +473,10 @@ class Transaction_test : public beast::unit_test::Suite
             auto const result =
                 env.rpc(command, ctid, binary, to_string(-1), to_string(deletedLedger - 1));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcInvalidLgrRange);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Ledger range is invalid.");
 
             BEAST_EXPECT(!result[jss::result].isMember(jss::searched_all));
         }
@@ -470,9 +485,10 @@ class Transaction_test : public beast::unit_test::Suite
         {
             auto const result = env.rpc(command, ctid, binary, to_string(-20), to_string(-10));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcInvalidLgrRange);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Ledger range is invalid.");
 
             BEAST_EXPECT(!result[jss::result].isMember(jss::searched_all));
         }
@@ -481,9 +497,10 @@ class Transaction_test : public beast::unit_test::Suite
         {
             auto const result = env.rpc(command, ctid, binary, to_string(20));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == invalid);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcInvalidLgrRange);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Ledger range is invalid.");
 
             BEAST_EXPECT(!result[jss::result].isMember(jss::searched_all));
         }
@@ -507,9 +524,10 @@ class Transaction_test : public beast::unit_test::Suite
             auto const result = env.rpc(
                 command, ctid, binary, to_string(startLegSeq), to_string(startLegSeq + 1001));
 
-            BEAST_EXPECT(
-                result[jss::result][jss::status] == jss::error &&
-                result[jss::result][jss::error] == excessive);
+            BEAST_EXPECT(result[jss::result][jss::status] == jss::error);
+            BEAST_EXPECT(result[jss::result][jss::error] == excessive);
+            BEAST_EXPECT(result[jss::result][jss::error_code] == RpcExcessiveLgrRange);
+            BEAST_EXPECT(result[jss::result][jss::error_message] == "Ledger range exceeds 1000.");
 
             BEAST_EXPECT(!result[jss::result].isMember(jss::searched_all));
         }
@@ -945,6 +963,7 @@ class Transaction_test : public beast::unit_test::Suite
             auto result = signFor(env, tx);
 
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Missing field 'tx_json.NetworkID'.");
         }
 
@@ -958,6 +977,7 @@ class Transaction_test : public beast::unit_test::Suite
             auto result = signFor(env, tx);
 
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Invalid field 'tx_json.NetworkID'.");
         }
 
@@ -971,6 +991,7 @@ class Transaction_test : public beast::unit_test::Suite
             auto result = signFor(env, tx);
 
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Invalid field 'tx_json.NetworkID'.");
         }
 
@@ -985,6 +1006,7 @@ class Transaction_test : public beast::unit_test::Suite
             auto result = signFor(env, tx);
 
             BEAST_EXPECT(result[jss::error] == "invalidParams");
+            BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(result[jss::error_message] == "Invalid field 'tx_json.NetworkID'.");
         }
 

src/test/rpc/ValidatorInfo_test.cpp

@@ -7,6 +7,7 @@
 
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/config/Constants.h>
+#include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/jss.h>
 
 #include <memory>
@@ -27,6 +28,8 @@ public:
         {
             Env env(*this);
             auto const info = env.rpc("validator_info");
+            BEAST_EXPECT(info[jss::result][jss::error] == "invalidParams");
+            BEAST_EXPECT(info[jss::result][jss::error_code] == RpcInvalidParams);
             BEAST_EXPECT(info[jss::result][jss::error_message] == "not a validator");
         }
     }

src/test/server/ServerStatus_test.cpp

@@ -306,33 +306,57 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En
             // 1 - FAILS with wrong pass
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             jrr = makeAdminRequest(env, proto, *user, *password + "_")[jss::result];
-            BEAST_EXPECT(jrr["error"] == protoWs ? "forbidden" : "noPermission");
-            BEAST_EXPECT(
-                jrr["error_message"] == protoWs ? "Bad credentials."
-                                                : "You don't have permission for this command.");
+            if (protoWs)
+            {
+                BEAST_EXPECT(jrr[jss::error] == "forbidden");
+                BEAST_EXPECT(jrr[jss::error_code] == RpcForbidden);
+                BEAST_EXPECT(jrr[jss::error_message] == "Bad credentials.");
+            }
+            else
+            {
+                BEAST_EXPECT(jrr.isNull());
+            }
 
             // 2 - FAILS with password in an object
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             jrr = makeAdminRequest(env, proto, *user, *password, true)[jss::result];
-            BEAST_EXPECT(jrr["error"] == protoWs ? "forbidden" : "noPermission");
-            BEAST_EXPECT(
-                jrr["error_message"] == protoWs ? "Bad credentials."
-                                                : "You don't have permission for this command.");
+            if (protoWs)
+            {
+                BEAST_EXPECT(jrr[jss::error] == "forbidden");
+                BEAST_EXPECT(jrr[jss::error_code] == RpcForbidden);
+                BEAST_EXPECT(jrr[jss::error_message] == "Bad credentials.");
+            }
+            else
+            {
+                BEAST_EXPECT(jrr.isNull());
+            }
 
             // 3 - FAILS with wrong user
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             jrr = makeAdminRequest(env, proto, *user + "_", *password)[jss::result];
-            BEAST_EXPECT(jrr["error"] == protoWs ? "forbidden" : "noPermission");
-            BEAST_EXPECT(
-                jrr["error_message"] == protoWs ? "Bad credentials."
-                                                : "You don't have permission for this command.");
+            if (protoWs)
+            {
+                BEAST_EXPECT(jrr[jss::error] == "forbidden");
+                BEAST_EXPECT(jrr[jss::error_code] == RpcForbidden);
+                BEAST_EXPECT(jrr[jss::error_message] == "Bad credentials.");
+            }
+            else
+            {
+                BEAST_EXPECT(jrr.isNull());
+            }
 
             // 4 - FAILS no credentials
             jrr = makeAdminRequest(env, proto, "", "")[jss::result];
-            BEAST_EXPECT(jrr["error"] == protoWs ? "forbidden" : "noPermission");
-            BEAST_EXPECT(
-                jrr["error_message"] == protoWs ? "Bad credentials."
-                                                : "You don't have permission for this command.");
+            if (protoWs)
+            {
+                BEAST_EXPECT(jrr[jss::error] == "forbidden");
+                BEAST_EXPECT(jrr[jss::error_code] == RpcForbidden);
+                BEAST_EXPECT(jrr[jss::error_message] == "Bad credentials.");
+            }
+            else
+            {
+                BEAST_EXPECT(jrr.isNull());
+            }
 
             // 5 - SUCCEEDS with proper credentials
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
@@ -353,10 +377,16 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En
         {
             // 1 - FAILS - admin disabled
             jrr = makeAdminRequest(env, proto, "", "")[jss::result];
-            BEAST_EXPECT(jrr["error"] == protoWs ? "forbidden" : "noPermission");
-            BEAST_EXPECT(
-                jrr["error_message"] == protoWs ? "Bad credentials."
-                                                : "You don't have permission for this command.");
+            if (protoWs)
+            {
+                BEAST_EXPECT(jrr[jss::error] == "forbidden");
+                BEAST_EXPECT(jrr[jss::error_code] == RpcForbidden);
+                BEAST_EXPECT(jrr[jss::error_message] == "Bad credentials.");
+            }
+            else
+            {
+                BEAST_EXPECT(jrr.isNull());
+            }
         }
     }
 
@@ -730,7 +760,9 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En
 
         {  // send invalid json
             auto resp = sendAndParse("NOT JSON");
-            BEAST_EXPECT(resp.isMember(jss::error) && resp[jss::error] == "jsonInvalid");
+            BEAST_EXPECT(resp[jss::error] == "jsonInvalid");
+            BEAST_EXPECT(!resp.isMember(jss::error_code));
+            BEAST_EXPECT(resp[jss::error_message].isNull());
             BEAST_EXPECT(!resp.isMember(jss::status));
         }
 
@@ -739,8 +771,10 @@ class ServerStatus_test : public beast::unit_test::Suite, public beast::test::En
             jv[jss::command] = "foo";
             jv[jss::method] = "bar";
             auto resp = sendAndParse(to_string(jv));
-            BEAST_EXPECT(resp.isMember(jss::error) && resp[jss::error] == "missingCommand");
-            BEAST_EXPECT(resp.isMember(jss::status) && resp[jss::status] == "error");
+            BEAST_EXPECT(resp[jss::status] == "error");
+            BEAST_EXPECT(resp[jss::error] == "missingCommand");
+            BEAST_EXPECT(!resp.isMember(jss::error_code));
+            BEAST_EXPECT(resp[jss::error_message].isNull());
         }
 
         {  // send a ping (not an error)