diff --git a/.github/actions/build/action.yml b/.github/actions/build/action.yml
index 2c4135e0cf1..d7a92b3b409 100644
--- a/.github/actions/build/action.yml
+++ b/.github/actions/build/action.yml
@@ -10,16 +10,12 @@ inputs:
 runs:
   using: composite
   steps:
-    - name: dependencies
-      uses: ./.github/actions/dependencies
-      with:
-        configuration: ${{ inputs.configuration }}
     - name: configure
       shell: bash
       run: |
         cd ${build_dir}
         cmake \
-          ${{ inputs.generator && format('-G {0}', inputs.generator) || '' }} \
+          ${{ inputs.generator && format('-G "{0}"', inputs.generator) || '' }} \
           -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
           -DCMAKE_BUILD_TYPE=${{ inputs.configuration }} \
           ${{ inputs.cmake-args }} \
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index ca7367b8753..f3c5edd0b0b 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -33,10 +33,27 @@ Please check [x] relevant options, delete irrelevant ones.
 - [ ] New feature (non-breaking change which adds functionality)
 - [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
 - [ ] Refactor (non-breaking change that only restructures code)
-- [ ] Tests (You added tests for code that already exists, or your new feature included in this PR)
-- [ ] Documentation Updates
+- [ ] Tests (you added tests for code that already exists, or your new feature included in this PR)
+- [ ] Documentation update
+- [ ] Chore (no impact to binary, e.g. `.gitignore`, formatting, dropping support for older tooling)
 - [ ] Release
 
+### API Impact
+
+<!--
+Please check [x] relevant options, delete irrelevant ones.
+
+* If there is any impact to the public API methods (HTTP / WebSocket), please update https://github.com/xrplf/rippled/blob/develop/API-CHANGELOG.md
+  * Update API-CHANGELOG.md and add the change directly in this PR by pushing to your PR branch.
+* libxrpl: See https://github.com/XRPLF/rippled/blob/develop/docs/build/depend.md
+* Peer Protocol: See https://xrpl.org/peer-protocol.html
+-->
+
+- [ ] Public API: New feature (new methods and/or new fields)
+- [ ] Public API: Breaking change (in general, breaking changes should only impact the next api_version)
+- [ ] `libxrpl` change (any change that may affect `libxrpl` or dependents of `libxrpl`)
+- [ ] Peer protocol change (must be backward compatible or bump the peer protocol version)
+
 <!--
 ## Before / After
 If relevant, use this section for an English description of the change at a technical level.
diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index 1ebb9f690bb..120a6ec1782 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -37,6 +37,10 @@ jobs:
         run : |
           conan profile get env.CXXFLAGS default || true
           conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_DISABLE_CONCEPTS"]' default
+      - name: dependencies
+        uses: ./.github/actions/dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
       - name: build
         uses: ./.github/actions/build
         with:
diff --git a/.github/workflows/nix.yml b/.github/workflows/nix.yml
index 4198369e78a..e43ae1379c9 100644
--- a/.github/workflows/nix.yml
+++ b/.github/workflows/nix.yml
@@ -79,7 +79,7 @@ jobs:
       - name: try to authenticate to ripple Conan remote
         id: remote
         run: |
-          echo outcome=$(conan user --remote ripple ${{ secrets.CONAN_USERNAME }} --password ${{ secrets.CONAN_TOKEN }} && echo success || echo failure) | tee ${GITHUB_OUTPUT}
+          echo outcome=$(conan user --remote ripple ${{ secrets.CONAN_USERNAME }} --password ${{ secrets.CONAN_TOKEN }} >&2 && echo success || echo failure) | tee ${GITHUB_OUTPUT}
       - name: archive profile
         # Create this archive before dependencies are added to the local cache.
         run: tar -czf conan.tar -C ~/.conan .
@@ -88,7 +88,7 @@ jobs:
         # Print the list of dependencies that would need to be built locally.
         # A non-empty list means we have "failed" to cache binaries remotely.
         run: |
-          echo missing=$(conan info . --build missing --json 2>/dev/null  | grep '^\[') | tee ${GITHUB_OUTPUT}
+          echo missing=$(conan info . --build missing --settings build_type=${{ matrix.configuration }} --json 2>/dev/null  | grep '^\[') | tee ${GITHUB_OUTPUT}
       - name: build dependencies
         if: (steps.binaries.outputs.missing != '[]')
         uses: ./.github/actions/dependencies
@@ -146,6 +146,10 @@ jobs:
           ls ~/.conan
       - name: checkout
         uses: actions/checkout@v3
+      - name: dependencies
+        uses: ./.github/actions/dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
       - name: build
         uses: ./.github/actions/build
         with:
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index 0f918a50959..98cbb9acc40 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -1,19 +1,11 @@
 name: windows
-# We have disabled this workflow because it fails in our CI Windows
-# environment, but we cannot replicate the failure in our personal Windows
-# test environments, nor have we gone through the trouble of setting up an
-# interactive CI Windows environment.
-# We welcome contributions to diagnose or debug the problems on Windows. Until
-# then, we leave this tombstone as a reminder that we have tried (but failed)
-# to write a reliable test for Windows.
-# on: [push, pull_request]
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - 'action'
-    paths:
-      - '.github/workflow/windows.yml'
+
+on: [push, pull_request]
+
+# https://docs.github.com/en/actions/using-jobs/using-concurrency
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 jobs:
 
@@ -25,6 +17,11 @@ jobs:
           - Visual Studio 16 2019
         configuration:
           - Release
+          # Github hosted runners tend to hang when running Debug unit tests.
+          # Instead of trying to work around it, disable the Debug job until
+          # something beefier (i.e. a heavy self-hosted runner) becomes
+          # available.
+          # - Debug
     runs-on: windows-2019
     env:
       build_dir: .build
@@ -37,11 +34,12 @@ jobs:
           python-version: 3.9
       - name: learn Python cache directory
         id: pip-cache
+        shell: bash
         run: |
-          pip install --upgrade pip
-          echo "dir=$(pip cache dir)" >> $GITHUB_OUTPUT
+          python -m pip install --upgrade pip
+          echo "dir=$(pip cache dir)" | tee ${GITHUB_OUTPUT}
       - name: restore Python cache directory
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
             path: ${{ steps.pip-cache.outputs.dir }}
             key: ${{ runner.os }}-${{ hashFiles('.github/workflows/windows.yml') }}
@@ -55,45 +53,48 @@ jobs:
           cmake --version
           dir env:
       - name: configure Conan
+        shell: bash
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
         run: |
           conan profile new default --detect
-          conan profile update settings.compiler.cppstd=20 default
-          conan profile update settings.compiler.runtime=MT default
-          conan profile update settings.compiler.toolset=v141 default
-      - name: learn Conan cache directory
-        id: conan-cache
-        run: |
-          echo "dir=$(conan config get storage.path)" >> $GITHUB_OUTPUT
-      - name: restore Conan cache directory
-        uses: actions/cache@v2
-        with:
-            path: ${{ steps.conan-cache.outputs.dir }}
-            key: ${{ hashFiles('~/.conan/profiles/default', 'conanfile.py', 'external/rocksdb/*', '.github/workflows/windows.yml') }}
-      - name: export custom recipes
+          conan profile update settings.compiler.runtime=MT${{ matrix.configuration == 'Debug' && 'd' || '' }} default
+          # Do not quote the URL. An empty string will be accepted (with
+          # a non-fatal warning), but a missing argument will not.
+          conan remote add ripple ${{ env.CONAN_URL }} --insert 0
+      - name: try to authenticate to ripple Conan remote
+        shell: bash
+        id: remote
         run: |
-          conan export external/snappy snappy/1.1.9@
-          conan export external/soci soci/4.0.3@
-      - name: install dependencies
+          echo outcome=$(conan user --remote ripple ${{ secrets.CONAN_USERNAME }} \
+            --password ${{ secrets.CONAN_TOKEN }} >&2 && echo success || \
+            echo failure) | tee ${GITHUB_OUTPUT}
+      - name: list missing binaries
+        id: binaries
+        shell: bash
+        # Print the list of dependencies that would need to be built locally.
+        # A non-empty list means we have "failed" to cache binaries remotely.
         run: |
-          mkdir $env:build_dir
-          cd $env:build_dir
-          conan install .. --build missing --settings build_type=${{ matrix.configuration }}
-      - name: configure
-        run: |
-          $env:build_dir
-          cd $env:build_dir
-          pwd
-          ls
-          cmake `
-            -G "${{ matrix.generator }}" `
-            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake `
-            -Dassert=ON `
-            -Dreporting=OFF `
-            -Dunity=OFF `
-            ..
+          echo missing=$(conan info . --build missing --settings build_type=${{ matrix.configuration }} --json 2>/dev/null  | grep '^\[') | tee ${GITHUB_OUTPUT}
+      - name: build dependencies
+        uses: ./.github/actions/dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
+      - name: upload dependencies to remote
+        if: (steps.binaries.outputs.missing != '[]') && (steps.remote.outputs.outcome == 'success')
+        run: conan upload --remote ripple '*' --all --parallel --confirm
       - name: build
+        uses: ./.github/actions/build
+        with:
+          generator: '${{ matrix.generator }}'
+          configuration: ${{ matrix.configuration }}
+          # Hard code for now. Move to the matrix if varied options are needed
+          cmake-args: '-Dassert=ON -Dreporting=OFF -Dunity=OFF'
+      - name: test (permitted to silently fail)
+        shell: bash
+        # Github runners are resource limited, which causes unit tests to fail
+        # (e.g. OOM). To allow forward progress until self-hosted runners are
+        # up and running reliably, allow the job to succeed even if tests fail.
+        continue-on-error: true
         run: |
-          cmake --build $env:build_dir --target rippled --config ${{ matrix.configuration }} --parallel $env:NUMBER_OF_PROCESSORS
-      - name: test
-        run: |
-          & "$env:build_dir\${{ matrix.configuration }}\rippled.exe" --unittest
+          ${build_dir}/${{ matrix.configuration }}/rippled --unittest --unittest-jobs $(nproc)
diff --git a/API-CHANGELOG.md b/API-CHANGELOG.md
index 7579a40b72c..a3c06399cf5 100644
--- a/API-CHANGELOG.md
+++ b/API-CHANGELOG.md
@@ -26,6 +26,14 @@ In `api_version: 2`, the `signer_lists` field [will be moved](#modifications-to-
 
 The `network_id` field was added in the `server_info` response in version 1.5.0 (2019), but it was not returned in [reporting mode](https://xrpl.org/rippled-server-modes.html#reporting-mode).
 
+## Unreleased
+
+### Additions
+
+Additions are intended to be non-breaking (because they are purely additive).
+
+- `server_definitions`: A new RPC that generates a `definitions.json`-like output that can be used in XRPL libraries.
+
 ## XRP Ledger version 1.12.0
 
 [Version 1.12.0](https://github.com/XRPLF/rippled/releases/tag/1.12.0) was released on Sep 6, 2023.
@@ -46,27 +54,27 @@ Additions are intended to be non-breaking (because they are purely additive).
     - `Account`: The issuer of the asset being clawed back. Must also be the sender of the transaction.
     - `Amount`: The amount being clawed back, with the `Amount.issuer` being the token holder's address.
 - Adds [AMM](https://github.com/XRPLF/XRPL-Standards/discussions/78) ([#4294](https://github.com/XRPLF/rippled/pull/4294), [#4626](https://github.com/XRPLF/rippled/pull/4626)) feature:
-    - Adds `amm_info` API to retrieve AMM information for a given tokens pair.
-    - Adds `AMMCreate` transaction type to create `AMM` instance.
-    - Adds `AMMDeposit` transaction type to deposit funds into `AMM` instance.
-    - Adds `AMMWithdraw` transaction type to withdraw funds from `AMM` instance.
-    - Adds `AMMVote` transaction type to vote for the trading fee of `AMM` instance.
-    - Adds `AMMBid` transaction type to bid for the Auction Slot of `AMM` instance.
-    - Adds `AMMDelete` transaction type to delete `AMM` instance.
-    - Adds `sfAMMID` to `AccountRoot` to indicate that the account is `AMM`'s account. `AMMID` is used to fetch `ltAMM`.
-    - Adds `lsfAMMNode` `TrustLine` flag to indicate that one side of the `TrustLine` is `AMM` account.
-    - Adds `tfLPToken`, `tfSingleAsset`, `tfTwoAsset`, `tfOneAssetLPToken`, `tfLimitLPToken`, `tfTwoAssetIfEmpty`,
-      `tfWithdrawAll`, `tfOneAssetWithdrawAll` which allow a trader to specify different fields combination 
-      for `AMMDeposit` and `AMMWithdraw` transactions.
-    - Adds new transaction result codes:
-       - tecUNFUNDED_AMM: insufficient balance to fund AMM. The account does not have funds for liquidity provision.
-       -  tecAMM_BALANCE: AMM has invalid balance. Calculated balances greater than the current pool balances.
-       -  tecAMM_FAILED: AMM transaction failed. Fails due to a processing failure.
-       -  tecAMM_INVALID_TOKENS: AMM invalid LP tokens. Invalid input values, format, or calculated values.
-       -  tecAMM_EMPTY: AMM is in empty state. Transaction expects AMM in non-empty state (LP tokens > 0).
-       -  tecAMM_NOT_EMPTY: AMM is not in empty state. Transaction expects AMM in empty state (LP tokens == 0).
-       -  tecAMM_ACCOUNT: AMM account. Clawback of AMM account.
-       -  tecINCOMPLETE: Some work was completed, but more submissions required to finish. AMMDelete partially deletes the trustlines.
+  - Adds `amm_info` API to retrieve AMM information for a given tokens pair.
+  - Adds `AMMCreate` transaction type to create `AMM` instance.
+  - Adds `AMMDeposit` transaction type to deposit funds into `AMM` instance.
+  - Adds `AMMWithdraw` transaction type to withdraw funds from `AMM` instance.
+  - Adds `AMMVote` transaction type to vote for the trading fee of `AMM` instance.
+  - Adds `AMMBid` transaction type to bid for the Auction Slot of `AMM` instance.
+  - Adds `AMMDelete` transaction type to delete `AMM` instance.
+  - Adds `sfAMMID` to `AccountRoot` to indicate that the account is `AMM`'s account. `AMMID` is used to fetch `ltAMM`.
+  - Adds `lsfAMMNode` `TrustLine` flag to indicate that one side of the `TrustLine` is `AMM` account.
+  - Adds `tfLPToken`, `tfSingleAsset`, `tfTwoAsset`, `tfOneAssetLPToken`, `tfLimitLPToken`, `tfTwoAssetIfEmpty`,
+    `tfWithdrawAll`, `tfOneAssetWithdrawAll` which allow a trader to specify different fields combination
+    for `AMMDeposit` and `AMMWithdraw` transactions.
+  - Adds new transaction result codes:
+    - tecUNFUNDED_AMM: insufficient balance to fund AMM. The account does not have funds for liquidity provision.
+    - tecAMM_BALANCE: AMM has invalid balance. Calculated balances greater than the current pool balances.
+    - tecAMM_FAILED: AMM transaction failed. Fails due to a processing failure.
+    - tecAMM_INVALID_TOKENS: AMM invalid LP tokens. Invalid input values, format, or calculated values.
+    - tecAMM_EMPTY: AMM is in empty state. Transaction expects AMM in non-empty state (LP tokens > 0).
+    - tecAMM_NOT_EMPTY: AMM is not in empty state. Transaction expects AMM in empty state (LP tokens == 0).
+    - tecAMM_ACCOUNT: AMM account. Clawback of AMM account.
+    - tecINCOMPLETE: Some work was completed, but more submissions required to finish. AMMDelete partially deletes the trustlines.
 
 ## XRP Ledger version 1.11.0
 
@@ -98,6 +106,17 @@ Additions are intended to be non-breaking (because they are purely additive).
 - Added `NFTokenPages` to the `account_objects` RPC. (https://github.com/XRPLF/rippled/pull/4352)
 - Fixed: `marker` returned from the `account_lines` command would not work on subsequent commands. (https://github.com/XRPLF/rippled/pull/4361)
 
+## XRP Ledger version 1.10.0
+
+[Version 1.10.0](https://github.com/XRPLF/rippled/releases/tag/1.10.0)
+was released on Mar 14, 2023.
+
+### Breaking changes in 1.10
+
+- If the `XRPFees` feature is enabled, the `fee_ref` field will be
+  removed from the [ledger subscription stream](https://xrpl.org/subscribe.html#ledger-stream), because it will no longer
+  have any meaning.
+
 # In development
 
 Changes below this point are in development.
@@ -107,6 +126,7 @@ Changes below this point are in development.
 At the time of writing, this version is expected to be introduced in `rippled` version 2.0.
 
 Currently (prior to the release of 2.0), it is available as a "beta" version, meaning it can be enabled with a config setting in `rippled.cfg`:
+
 ```
 [beta_rpc_api]
 1
diff --git a/Builds/CMake/RippledCore.cmake b/Builds/CMake/RippledCore.cmake
index 8d2ff6cbaef..ef6f925ec6d 100644
--- a/Builds/CMake/RippledCore.cmake
+++ b/Builds/CMake/RippledCore.cmake
@@ -519,6 +519,7 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/CreateTicket.cpp
   src/ripple/app/tx/impl/DeleteAccount.cpp
   src/ripple/app/tx/impl/DepositPreauth.cpp
+  src/ripple/app/tx/impl/DID.cpp
   src/ripple/app/tx/impl/Escrow.cpp
   src/ripple/app/tx/impl/InvariantCheck.cpp
   src/ripple/app/tx/impl/NFTokenAcceptOffer.cpp
@@ -785,6 +786,7 @@ if (tests)
     src/test/app/DeliverMin_test.cpp
     src/test/app/DepositAuth_test.cpp
     src/test/app/Discrepancy_test.cpp
+    src/test/app/DID_test.cpp
     src/test/app/DNS_test.cpp
     src/test/app/Escrow_test.cpp
     src/test/app/FeeVote_test.cpp
@@ -937,6 +939,7 @@ if (tests)
     src/test/jtx/impl/check.cpp
     src/test/jtx/impl/delivermin.cpp
     src/test/jtx/impl/deposit.cpp
+    src/test/jtx/impl/did.cpp
     src/test/jtx/impl/envconfig.cpp
     src/test/jtx/impl/fee.cpp
     src/test/jtx/impl/flags.cpp
diff --git a/cfg/rippled-example.cfg b/cfg/rippled-example.cfg
index e21197eed5a..a3bcf0056be 100644
--- a/cfg/rippled-example.cfg
+++ b/cfg/rippled-example.cfg
@@ -389,6 +389,21 @@
 #
 #
 #
+# [compression]
+#
+#   true or false
+#
+#   true - enables compression
+#   false - disables compression [default].
+#
+#   The rippled server can save bandwidth by compressing its peer-to-peer communications, 
+#   at a cost of greater CPU usage. If you enable link compression, 
+#   the server automatically compresses communications with peer servers
+#   that also have link compression enabled.
+#   https://xrpl.org/enable-link-compression.html
+#
+#
+#
 # [ips]
 #
 #   List of hostnames or ips where the Ripple protocol is served.  A default
diff --git a/docs/build/conan.md b/docs/build/conan.md
index 01fb7150d38..210db18a5df 100644
--- a/docs/build/conan.md
+++ b/docs/build/conan.md
@@ -69,7 +69,7 @@ compiler and linker options for all dependencies _and_ this project.
 However, that is very tedious and error-prone, which is why we lean on tools
 like Conan.
 
-We have written a Conan configuration file ([`conanfile.py`](./conanfile.py))
+We have written a Conan configuration file ([`conanfile.py`](../../conanfile.py))
 so that Conan can be used to correctly download, configure, build, and install
 all of the dependencies for this project,
 using a single set of compiler and linker options for all of them.
diff --git a/src/ripple/app/main/Main.cpp b/src/ripple/app/main/Main.cpp
index a998640c01c..2ddb771b1e1 100644
--- a/src/ripple/app/main/Main.cpp
+++ b/src/ripple/app/main/Main.cpp
@@ -169,6 +169,7 @@ printHelp(const po::options_description& desc)
            "     peer_reservations_list\n"
            "     ripple ...\n"
            "     ripple_path_find <json> [<ledger>]\n"
+           "     server_definitions [<hash>]\n"
            "     server_info [counters]\n"
            "     server_state [counters]\n"
            "     sign <private_key> <tx_json> [offline]\n"
diff --git a/src/ripple/app/paths/PathRequest.cpp b/src/ripple/app/paths/PathRequest.cpp
index 02b46c81e91..f2aa363f934 100644
--- a/src/ripple/app/paths/PathRequest.cpp
+++ b/src/ripple/app/paths/PathRequest.cpp
@@ -538,7 +538,6 @@ PathRequest::findPaths(
             continueCallback);
         if (!pathfinder)
         {
-            assert(continueCallback && !continueCallback());
             JLOG(m_journal.debug()) << iIdentifier << " No paths found";
             continue;
         }
diff --git a/src/ripple/app/tx/impl/DID.cpp b/src/ripple/app/tx/impl/DID.cpp
new file mode 100644
index 00000000000..c92162c8306
--- /dev/null
+++ b/src/ripple/app/tx/impl/DID.cpp
@@ -0,0 +1,226 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2023 Ripple Labs Inc.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include <ripple/app/tx/impl/DID.h>
+
+#include <ripple/basics/Log.h>
+#include <ripple/ledger/ApplyView.h>
+#include <ripple/ledger/View.h>
+#include <ripple/protocol/Feature.h>
+#include <ripple/protocol/Indexes.h>
+#include <ripple/protocol/TxFlags.h>
+#include <ripple/protocol/st.h>
+
+namespace ripple {
+
+/*
+    DID
+    ======
+
+    Decentralized Identifiers (DIDs) are a new type of identifier that enable
+    verifiable, self-sovereign digital identity and are designed to be
+    compatible with any distributed ledger or network. This implementation
+    conforms to the requirements specified in the DID v1.0 specification
+    currently recommended by the W3C Credentials Community Group
+    (https://www.w3.org/TR/did-core/).
+*/
+
+//------------------------------------------------------------------------------
+
+NotTEC
+DIDSet::preflight(PreflightContext const& ctx)
+{
+    if (!ctx.rules.enabled(featureDID))
+        return temDISABLED;
+
+    if (ctx.tx.getFlags() & tfUniversalMask)
+        return temINVALID_FLAG;
+
+    if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
+        return ret;
+
+    if (!ctx.tx.isFieldPresent(sfURI) &&
+        !ctx.tx.isFieldPresent(sfDIDDocument) && !ctx.tx.isFieldPresent(sfData))
+        return temEMPTY_DID;
+
+    if (ctx.tx.isFieldPresent(sfURI) && ctx.tx[sfURI].empty() &&
+        ctx.tx.isFieldPresent(sfDIDDocument) && ctx.tx[sfDIDDocument].empty() &&
+        ctx.tx.isFieldPresent(sfData) && ctx.tx[sfData].empty())
+        return temEMPTY_DID;
+
+    auto isTooLong = [&](auto const& sField, std::size_t length) -> bool {
+        if (auto field = ctx.tx[~sField])
+            return field->length() > length;
+        return false;
+    };
+
+    if (isTooLong(sfURI, maxDIDURILength) ||
+        isTooLong(sfDIDDocument, maxDIDDocumentLength) ||
+        isTooLong(sfData, maxDIDAttestationLength))
+        return temMALFORMED;
+
+    return preflight2(ctx);
+}
+
+TER
+addSLE(
+    ApplyContext& ctx,
+    std::shared_ptr<SLE> const& sle,
+    AccountID const& owner)
+{
+    auto const sleAccount = ctx.view().peek(keylet::account(owner));
+    if (!sleAccount)
+        return tefINTERNAL;
+
+    // Check reserve availability for new object creation
+    {
+        auto const balance = STAmount((*sleAccount)[sfBalance]).xrp();
+        auto const reserve =
+            ctx.view().fees().accountReserve((*sleAccount)[sfOwnerCount] + 1);
+
+        if (balance < reserve)
+            return tecINSUFFICIENT_RESERVE;
+    }
+
+    // Add ledger object to ledger
+    ctx.view().insert(sle);
+
+    // Add ledger object to owner's page
+    {
+        auto page = ctx.view().dirInsert(
+            keylet::ownerDir(owner), sle->key(), describeOwnerDir(owner));
+        if (!page)
+            return tecDIR_FULL;
+        (*sle)[sfOwnerNode] = *page;
+    }
+    adjustOwnerCount(ctx.view(), sleAccount, 1, ctx.journal);
+    ctx.view().update(sleAccount);
+
+    return tesSUCCESS;
+}
+
+TER
+DIDSet::doApply()
+{
+    // Edit ledger object if it already exists
+    Keylet const didKeylet = keylet::did(account_);
+    if (auto const sleDID = ctx_.view().peek(didKeylet))
+    {
+        auto update = [&](auto const& sField) {
+            if (auto const field = ctx_.tx[~sField])
+            {
+                if (field->empty())
+                {
+                    sleDID->makeFieldAbsent(sField);
+                }
+                else
+                {
+                    (*sleDID)[sField] = *field;
+                }
+            }
+        };
+        update(sfURI);
+        update(sfDIDDocument);
+        update(sfData);
+
+        if (!sleDID->isFieldPresent(sfURI) &&
+            !sleDID->isFieldPresent(sfDIDDocument) &&
+            !sleDID->isFieldPresent(sfData))
+        {
+            return tecEMPTY_DID;
+        }
+        ctx_.view().update(sleDID);
+        return tesSUCCESS;
+    }
+
+    // Create new ledger object otherwise
+    auto const sleDID = std::make_shared<SLE>(didKeylet);
+    (*sleDID)[sfAccount] = account_;
+
+    auto set = [&](auto const& sField) {
+        if (auto const field = ctx_.tx[~sField]; field && !field->empty())
+            (*sleDID)[sField] = *field;
+    };
+
+    set(sfURI);
+    set(sfDIDDocument);
+    set(sfData);
+
+    return addSLE(ctx_, sleDID, account_);
+}
+
+NotTEC
+DIDDelete::preflight(PreflightContext const& ctx)
+{
+    if (!ctx.rules.enabled(featureDID))
+        return temDISABLED;
+
+    if (ctx.tx.getFlags() & tfUniversalMask)
+        return temINVALID_FLAG;
+
+    if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
+        return ret;
+
+    return preflight2(ctx);
+}
+
+TER
+DIDDelete::deleteSLE(ApplyContext& ctx, Keylet sleKeylet, AccountID const owner)
+{
+    auto const sle = ctx.view().peek(sleKeylet);
+    if (!sle)
+        return tecNO_ENTRY;
+
+    return DIDDelete::deleteSLE(ctx.view(), sle, owner, ctx.journal);
+}
+
+TER
+DIDDelete::deleteSLE(
+    ApplyView& view,
+    std::shared_ptr<SLE> sle,
+    AccountID const owner,
+    beast::Journal j)
+{
+    // Remove object from owner directory
+    if (!view.dirRemove(
+            keylet::ownerDir(owner), (*sle)[sfOwnerNode], sle->key(), true))
+    {
+        JLOG(j.fatal()) << "Unable to delete DID Token from owner.";
+        return tefBAD_LEDGER;
+    }
+
+    auto const sleOwner = view.peek(keylet::account(owner));
+    if (!sleOwner)
+        return tecINTERNAL;
+
+    adjustOwnerCount(view, sleOwner, -1, j);
+    view.update(sleOwner);
+
+    // Remove object from ledger
+    view.erase(sle);
+    return tesSUCCESS;
+}
+
+TER
+DIDDelete::doApply()
+{
+    return deleteSLE(ctx_, keylet::did(account_), account_);
+}
+
+}  // namespace ripple
diff --git a/src/ripple/app/tx/impl/DID.h b/src/ripple/app/tx/impl/DID.h
new file mode 100644
index 00000000000..13d5a261542
--- /dev/null
+++ b/src/ripple/app/tx/impl/DID.h
@@ -0,0 +1,73 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2012, 2013 Ripple Labs Inc.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef RIPPLE_TX_DID_H_INCLUDED
+#define RIPPLE_TX_DID_H_INCLUDED
+
+#include <ripple/app/tx/impl/Transactor.h>
+
+namespace ripple {
+
+class DIDSet : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit DIDSet(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+//------------------------------------------------------------------------------
+
+class DIDDelete : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit DIDDelete(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    deleteSLE(ApplyContext& ctx, Keylet sleKeylet, AccountID const owner);
+
+    static TER
+    deleteSLE(
+        ApplyView& view,
+        std::shared_ptr<SLE> sle,
+        AccountID const owner,
+        beast::Journal j);
+
+    TER
+    doApply() override;
+};
+
+}  // namespace ripple
+
+#endif
diff --git a/src/ripple/app/tx/impl/DeleteAccount.cpp b/src/ripple/app/tx/impl/DeleteAccount.cpp
index 67545723a5f..49b645e31d9 100644
--- a/src/ripple/app/tx/impl/DeleteAccount.cpp
+++ b/src/ripple/app/tx/impl/DeleteAccount.cpp
@@ -17,6 +17,7 @@
 */
 //==============================================================================
 
+#include <ripple/app/tx/impl/DID.h>
 #include <ripple/app/tx/impl/DeleteAccount.h>
 #include <ripple/app/tx/impl/DepositPreauth.h>
 #include <ripple/app/tx/impl/SetSignerList.h>
@@ -133,6 +134,18 @@ removeNFTokenOfferFromLedger(
     return tesSUCCESS;
 }
 
+TER
+removeDIDFromLedger(
+    Application& app,
+    ApplyView& view,
+    AccountID const& account,
+    uint256 const& delIndex,
+    std::shared_ptr<SLE> const& sleDel,
+    beast::Journal j)
+{
+    return DIDDelete::deleteSLE(view, sleDel, account, j);
+}
+
 // Return nullptr if the LedgerEntryType represents an obligation that can't
 // be deleted.  Otherwise return the pointer to the function that can delete
 // the non-obligation
@@ -151,6 +164,8 @@ nonObligationDeleter(LedgerEntryType t)
             return removeDepositPreauthFromLedger;
         case ltNFTOKEN_OFFER:
             return removeNFTokenOfferFromLedger;
+        case ltDID:
+            return removeDIDFromLedger;
         default:
             return nullptr;
     }
diff --git a/src/ripple/app/tx/impl/InvariantCheck.cpp b/src/ripple/app/tx/impl/InvariantCheck.cpp
index 7b1ac7d08df..c717777f88f 100644
--- a/src/ripple/app/tx/impl/InvariantCheck.cpp
+++ b/src/ripple/app/tx/impl/InvariantCheck.cpp
@@ -391,6 +391,7 @@ LedgerEntryTypesMatch::visitEntry(
             case ltBRIDGE:
             case ltXCHAIN_OWNED_CLAIM_ID:
             case ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID:
+            case ltDID:
                 break;
             default:
                 invalidTypeAdded_ = true;
diff --git a/src/ripple/app/tx/impl/SetTrust.cpp b/src/ripple/app/tx/impl/SetTrust.cpp
index 7869cc7027d..00a5165221e 100644
--- a/src/ripple/app/tx/impl/SetTrust.cpp
+++ b/src/ripple/app/tx/impl/SetTrust.cpp
@@ -140,7 +140,20 @@ SetTrust::preclaim(PreclaimContext const& ctx)
             return tecNO_DST;
 
         if (sleDst->getFlags() & lsfDisallowIncomingTrustline)
-            return tecNO_PERMISSION;
+        {
+            // The original implementation of featureDisallowIncoming was
+            // too restrictive.  If
+            //   o fixDisallowIncomingV1 is enabled and
+            //   o The trust line already exists
+            // Then allow the TrustSet.
+            if (ctx.view.rules().enabled(fixDisallowIncomingV1) &&
+                ctx.view.exists(keylet::line(id, uDstAccountID, currency)))
+            {
+                // pass
+            }
+            else
+                return tecNO_PERMISSION;
+        }
     }
 
     // If destination is AMM and the trustline doesn't exist then only
diff --git a/src/ripple/app/tx/impl/applySteps.cpp b/src/ripple/app/tx/impl/applySteps.cpp
index d4d9e72a830..10e2b0c4524 100644
--- a/src/ripple/app/tx/impl/applySteps.cpp
+++ b/src/ripple/app/tx/impl/applySteps.cpp
@@ -33,6 +33,7 @@
 #include <ripple/app/tx/impl/CreateCheck.h>
 #include <ripple/app/tx/impl/CreateOffer.h>
 #include <ripple/app/tx/impl/CreateTicket.h>
+#include <ripple/app/tx/impl/DID.h>
 #include <ripple/app/tx/impl/DeleteAccount.h>
 #include <ripple/app/tx/impl/DepositPreauth.h>
 #include <ripple/app/tx/impl/Escrow.h>
@@ -50,371 +51,244 @@
 #include <ripple/app/tx/impl/XChainBridge.h>
 #include <ripple/protocol/TxFormats.h>
 
+#include <stdexcept>
+
 namespace ripple {
 
-// Templates so preflight does the right thing with T::ConsequencesFactory.
-//
-// This could be done more easily using if constexpr, but Visual Studio
-// 2017 doesn't handle if constexpr correctly.  So once we're no longer
-// building with Visual Studio 2017 we can consider replacing the four
-// templates with a single template function that uses if constexpr.
-//
-// For Transactor::Normal
-template <
-    class T,
-    std::enable_if_t<T::ConsequencesFactory == Transactor::Normal, int> = 0>
-TxConsequences
-consequences_helper(PreflightContext const& ctx)
-{
-    return TxConsequences(ctx.tx);
-};
+namespace {
 
-// For Transactor::Blocker
-template <
-    class T,
-    std::enable_if_t<T::ConsequencesFactory == Transactor::Blocker, int> = 0>
-TxConsequences
-consequences_helper(PreflightContext const& ctx)
-{
-    return TxConsequences(ctx.tx, TxConsequences::blocker);
-};
-
-// For Transactor::Custom
-template <
-    class T,
-    std::enable_if_t<T::ConsequencesFactory == Transactor::Custom, int> = 0>
-TxConsequences
-consequences_helper(PreflightContext const& ctx)
+struct UnknownTxnType : std::exception
 {
-    return T::makeTxConsequences(ctx);
+    TxType txnType;
+    UnknownTxnType(TxType t) : txnType{t}
+    {
+    }
 };
 
-template <class T>
-std::pair<NotTEC, TxConsequences>
-invoke_preflight_helper(PreflightContext const& ctx)
+// Call a lambda with the concrete transaction type as a template parameter
+// throw an "UnknownTxnType" exception on error
+template <class F>
+auto
+with_txn_type(TxType txnType, F&& f)
 {
-    auto const tec = T::preflight(ctx);
-    return {
-        tec,
-        isTesSuccess(tec) ? consequences_helper<T>(ctx) : TxConsequences{tec}};
-}
-
-static std::pair<NotTEC, TxConsequences>
-invoke_preflight(PreflightContext const& ctx)
-{
-    switch (ctx.tx.getTxnType())
+    switch (txnType)
     {
         case ttACCOUNT_DELETE:
-            return invoke_preflight_helper<DeleteAccount>(ctx);
+            return f.template operator()<DeleteAccount>();
         case ttACCOUNT_SET:
-            return invoke_preflight_helper<SetAccount>(ctx);
+            return f.template operator()<SetAccount>();
         case ttCHECK_CANCEL:
-            return invoke_preflight_helper<CancelCheck>(ctx);
+            return f.template operator()<CancelCheck>();
         case ttCHECK_CASH:
-            return invoke_preflight_helper<CashCheck>(ctx);
+            return f.template operator()<CashCheck>();
         case ttCHECK_CREATE:
-            return invoke_preflight_helper<CreateCheck>(ctx);
+            return f.template operator()<CreateCheck>();
         case ttDEPOSIT_PREAUTH:
-            return invoke_preflight_helper<DepositPreauth>(ctx);
+            return f.template operator()<DepositPreauth>();
         case ttOFFER_CANCEL:
-            return invoke_preflight_helper<CancelOffer>(ctx);
+            return f.template operator()<CancelOffer>();
         case ttOFFER_CREATE:
-            return invoke_preflight_helper<CreateOffer>(ctx);
+            return f.template operator()<CreateOffer>();
         case ttESCROW_CREATE:
-            return invoke_preflight_helper<EscrowCreate>(ctx);
+            return f.template operator()<EscrowCreate>();
         case ttESCROW_FINISH:
-            return invoke_preflight_helper<EscrowFinish>(ctx);
+            return f.template operator()<EscrowFinish>();
         case ttESCROW_CANCEL:
-            return invoke_preflight_helper<EscrowCancel>(ctx);
+            return f.template operator()<EscrowCancel>();
         case ttPAYCHAN_CLAIM:
-            return invoke_preflight_helper<PayChanClaim>(ctx);
+            return f.template operator()<PayChanClaim>();
         case ttPAYCHAN_CREATE:
-            return invoke_preflight_helper<PayChanCreate>(ctx);
+            return f.template operator()<PayChanCreate>();
         case ttPAYCHAN_FUND:
-            return invoke_preflight_helper<PayChanFund>(ctx);
+            return f.template operator()<PayChanFund>();
         case ttPAYMENT:
-            return invoke_preflight_helper<Payment>(ctx);
+            return f.template operator()<Payment>();
         case ttREGULAR_KEY_SET:
-            return invoke_preflight_helper<SetRegularKey>(ctx);
+            return f.template operator()<SetRegularKey>();
         case ttSIGNER_LIST_SET:
-            return invoke_preflight_helper<SetSignerList>(ctx);
+            return f.template operator()<SetSignerList>();
         case ttTICKET_CREATE:
-            return invoke_preflight_helper<CreateTicket>(ctx);
+            return f.template operator()<CreateTicket>();
         case ttTRUST_SET:
-            return invoke_preflight_helper<SetTrust>(ctx);
+            return f.template operator()<SetTrust>();
         case ttAMENDMENT:
         case ttFEE:
         case ttUNL_MODIFY:
-            return invoke_preflight_helper<Change>(ctx);
+            return f.template operator()<Change>();
         case ttNFTOKEN_MINT:
-            return invoke_preflight_helper<NFTokenMint>(ctx);
+            return f.template operator()<NFTokenMint>();
         case ttNFTOKEN_BURN:
-            return invoke_preflight_helper<NFTokenBurn>(ctx);
+            return f.template operator()<NFTokenBurn>();
         case ttNFTOKEN_CREATE_OFFER:
-            return invoke_preflight_helper<NFTokenCreateOffer>(ctx);
+            return f.template operator()<NFTokenCreateOffer>();
         case ttNFTOKEN_CANCEL_OFFER:
-            return invoke_preflight_helper<NFTokenCancelOffer>(ctx);
+            return f.template operator()<NFTokenCancelOffer>();
         case ttNFTOKEN_ACCEPT_OFFER:
-            return invoke_preflight_helper<NFTokenAcceptOffer>(ctx);
+            return f.template operator()<NFTokenAcceptOffer>();
         case ttCLAWBACK:
-            return invoke_preflight_helper<Clawback>(ctx);
+            return f.template operator()<Clawback>();
         case ttAMM_CREATE:
-            return invoke_preflight_helper<AMMCreate>(ctx);
+            return f.template operator()<AMMCreate>();
         case ttAMM_DEPOSIT:
-            return invoke_preflight_helper<AMMDeposit>(ctx);
+            return f.template operator()<AMMDeposit>();
         case ttAMM_WITHDRAW:
-            return invoke_preflight_helper<AMMWithdraw>(ctx);
+            return f.template operator()<AMMWithdraw>();
         case ttAMM_VOTE:
-            return invoke_preflight_helper<AMMVote>(ctx);
+            return f.template operator()<AMMVote>();
         case ttAMM_BID:
-            return invoke_preflight_helper<AMMBid>(ctx);
+            return f.template operator()<AMMBid>();
         case ttAMM_DELETE:
-            return invoke_preflight_helper<AMMDelete>(ctx);
+            return f.template operator()<AMMDelete>();
         case ttXCHAIN_CREATE_BRIDGE:
-            return invoke_preflight_helper<XChainCreateBridge>(ctx);
+            return f.template operator()<XChainCreateBridge>();
         case ttXCHAIN_MODIFY_BRIDGE:
-            return invoke_preflight_helper<BridgeModify>(ctx);
+            return f.template operator()<BridgeModify>();
         case ttXCHAIN_CREATE_CLAIM_ID:
-            return invoke_preflight_helper<XChainCreateClaimID>(ctx);
+            return f.template operator()<XChainCreateClaimID>();
         case ttXCHAIN_COMMIT:
-            return invoke_preflight_helper<XChainCommit>(ctx);
+            return f.template operator()<XChainCommit>();
         case ttXCHAIN_CLAIM:
-            return invoke_preflight_helper<XChainClaim>(ctx);
+            return f.template operator()<XChainClaim>();
         case ttXCHAIN_ADD_CLAIM_ATTESTATION:
-            return invoke_preflight_helper<XChainAddClaimAttestation>(ctx);
+            return f.template operator()<XChainAddClaimAttestation>();
         case ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION:
-            return invoke_preflight_helper<XChainAddAccountCreateAttestation>(
-                ctx);
+            return f.template operator()<XChainAddAccountCreateAttestation>();
         case ttXCHAIN_ACCOUNT_CREATE_COMMIT:
-            return invoke_preflight_helper<XChainCreateAccountCommit>(ctx);
+            return f.template operator()<XChainCreateAccountCommit>();
+        case ttDID_SET:
+            return f.template operator()<DIDSet>();
+        case ttDID_DELETE:
+            return f.template operator()<DIDDelete>();
         default:
-            assert(false);
-            return {temUNKNOWN, TxConsequences{temUNKNOWN}};
+            throw UnknownTxnType(txnType);
     }
 }
+}  // namespace
 
-/* invoke_preclaim<T> uses name hiding to accomplish
-    compile-time polymorphism of (presumably) static
-    class functions for Transactor and derived classes.
-*/
+// Templates so preflight does the right thing with T::ConsequencesFactory.
+//
+// This could be done more easily using if constexpr, but Visual Studio
+// 2017 doesn't handle if constexpr correctly.  So once we're no longer
+// building with Visual Studio 2017 we can consider replacing the four
+// templates with a single template function that uses if constexpr.
+//
+// For Transactor::Normal
+//
+
+// clang-format off
+// Current formatter for rippled is based on clang-10, which does not handle `requires` clauses
+template <class T>
+requires(T::ConsequencesFactory == Transactor::Normal)
+TxConsequences
+    consequences_helper(PreflightContext const& ctx)
+{
+    return TxConsequences(ctx.tx);
+};
+
+// For Transactor::Blocker
+template <class T>
+requires(T::ConsequencesFactory == Transactor::Blocker)
+TxConsequences
+    consequences_helper(PreflightContext const& ctx)
+{
+    return TxConsequences(ctx.tx, TxConsequences::blocker);
+};
+
+// For Transactor::Custom
 template <class T>
+requires(T::ConsequencesFactory == Transactor::Custom)
+TxConsequences
+    consequences_helper(PreflightContext const& ctx)
+{
+    return T::makeTxConsequences(ctx);
+};
+// clang-format on
+
+static std::pair<NotTEC, TxConsequences>
+invoke_preflight(PreflightContext const& ctx)
+{
+    try
+    {
+        return with_txn_type(ctx.tx.getTxnType(), [&]<typename T>() {
+            auto const tec = T::preflight(ctx);
+            return std::make_pair(
+                tec,
+                isTesSuccess(tec) ? consequences_helper<T>(ctx)
+                                  : TxConsequences{tec});
+        });
+    }
+    catch (UnknownTxnType const& e)
+    {
+        // Should never happen
+        JLOG(ctx.j.fatal())
+            << "Unknown transaction type in preflight: " << e.txnType;
+        assert(false);
+        return {temUNKNOWN, TxConsequences{temUNKNOWN}};
+    }
+}
+
 static TER
 invoke_preclaim(PreclaimContext const& ctx)
 {
-    // If the transactor requires a valid account and the transaction doesn't
-    // list one, preflight will have already a flagged a failure.
-    auto const id = ctx.tx.getAccountID(sfAccount);
-
-    if (id != beast::zero)
+    try
     {
-        TER result = T::checkSeqProxy(ctx.view, ctx.tx, ctx.j);
+        // use name hiding to accomplish compile-time polymorphism of static
+        // class functions for Transactor and derived classes.
+        return with_txn_type(ctx.tx.getTxnType(), [&]<typename T>() {
+            // If the transactor requires a valid account and the transaction
+            // doesn't list one, preflight will have already a flagged a
+            // failure.
+            auto const id = ctx.tx.getAccountID(sfAccount);
 
-        if (result != tesSUCCESS)
-            return result;
+            if (id != beast::zero)
+            {
+                TER result = T::checkSeqProxy(ctx.view, ctx.tx, ctx.j);
 
-        result = T::checkPriorTxAndLastLedger(ctx);
+                if (result != tesSUCCESS)
+                    return result;
 
-        if (result != tesSUCCESS)
-            return result;
+                result = T::checkPriorTxAndLastLedger(ctx);
 
-        result = T::checkFee(ctx, calculateBaseFee(ctx.view, ctx.tx));
+                if (result != tesSUCCESS)
+                    return result;
 
-        if (result != tesSUCCESS)
-            return result;
+                result = T::checkFee(ctx, calculateBaseFee(ctx.view, ctx.tx));
 
-        result = T::checkSign(ctx);
+                if (result != tesSUCCESS)
+                    return result;
 
-        if (result != tesSUCCESS)
-            return result;
-    }
+                result = T::checkSign(ctx);
 
-    return T::preclaim(ctx);
-}
+                if (result != tesSUCCESS)
+                    return result;
+            }
 
-static TER
-invoke_preclaim(PreclaimContext const& ctx)
-{
-    switch (ctx.tx.getTxnType())
+            return T::preclaim(ctx);
+        });
+    }
+    catch (UnknownTxnType const& e)
     {
-        case ttACCOUNT_DELETE:
-            return invoke_preclaim<DeleteAccount>(ctx);
-        case ttACCOUNT_SET:
-            return invoke_preclaim<SetAccount>(ctx);
-        case ttCHECK_CANCEL:
-            return invoke_preclaim<CancelCheck>(ctx);
-        case ttCHECK_CASH:
-            return invoke_preclaim<CashCheck>(ctx);
-        case ttCHECK_CREATE:
-            return invoke_preclaim<CreateCheck>(ctx);
-        case ttDEPOSIT_PREAUTH:
-            return invoke_preclaim<DepositPreauth>(ctx);
-        case ttOFFER_CANCEL:
-            return invoke_preclaim<CancelOffer>(ctx);
-        case ttOFFER_CREATE:
-            return invoke_preclaim<CreateOffer>(ctx);
-        case ttESCROW_CREATE:
-            return invoke_preclaim<EscrowCreate>(ctx);
-        case ttESCROW_FINISH:
-            return invoke_preclaim<EscrowFinish>(ctx);
-        case ttESCROW_CANCEL:
-            return invoke_preclaim<EscrowCancel>(ctx);
-        case ttPAYCHAN_CLAIM:
-            return invoke_preclaim<PayChanClaim>(ctx);
-        case ttPAYCHAN_CREATE:
-            return invoke_preclaim<PayChanCreate>(ctx);
-        case ttPAYCHAN_FUND:
-            return invoke_preclaim<PayChanFund>(ctx);
-        case ttPAYMENT:
-            return invoke_preclaim<Payment>(ctx);
-        case ttREGULAR_KEY_SET:
-            return invoke_preclaim<SetRegularKey>(ctx);
-        case ttSIGNER_LIST_SET:
-            return invoke_preclaim<SetSignerList>(ctx);
-        case ttTICKET_CREATE:
-            return invoke_preclaim<CreateTicket>(ctx);
-        case ttTRUST_SET:
-            return invoke_preclaim<SetTrust>(ctx);
-        case ttAMENDMENT:
-        case ttFEE:
-        case ttUNL_MODIFY:
-            return invoke_preclaim<Change>(ctx);
-        case ttNFTOKEN_MINT:
-            return invoke_preclaim<NFTokenMint>(ctx);
-        case ttNFTOKEN_BURN:
-            return invoke_preclaim<NFTokenBurn>(ctx);
-        case ttNFTOKEN_CREATE_OFFER:
-            return invoke_preclaim<NFTokenCreateOffer>(ctx);
-        case ttNFTOKEN_CANCEL_OFFER:
-            return invoke_preclaim<NFTokenCancelOffer>(ctx);
-        case ttNFTOKEN_ACCEPT_OFFER:
-            return invoke_preclaim<NFTokenAcceptOffer>(ctx);
-        case ttCLAWBACK:
-            return invoke_preclaim<Clawback>(ctx);
-        case ttAMM_CREATE:
-            return invoke_preclaim<AMMCreate>(ctx);
-        case ttAMM_DEPOSIT:
-            return invoke_preclaim<AMMDeposit>(ctx);
-        case ttAMM_WITHDRAW:
-            return invoke_preclaim<AMMWithdraw>(ctx);
-        case ttAMM_VOTE:
-            return invoke_preclaim<AMMVote>(ctx);
-        case ttAMM_BID:
-            return invoke_preclaim<AMMBid>(ctx);
-        case ttAMM_DELETE:
-            return invoke_preclaim<AMMDelete>(ctx);
-        case ttXCHAIN_CREATE_BRIDGE:
-            return invoke_preclaim<XChainCreateBridge>(ctx);
-        case ttXCHAIN_MODIFY_BRIDGE:
-            return invoke_preclaim<BridgeModify>(ctx);
-        case ttXCHAIN_CREATE_CLAIM_ID:
-            return invoke_preclaim<XChainCreateClaimID>(ctx);
-        case ttXCHAIN_COMMIT:
-            return invoke_preclaim<XChainCommit>(ctx);
-        case ttXCHAIN_CLAIM:
-            return invoke_preclaim<XChainClaim>(ctx);
-        case ttXCHAIN_ACCOUNT_CREATE_COMMIT:
-            return invoke_preclaim<XChainCreateAccountCommit>(ctx);
-        case ttXCHAIN_ADD_CLAIM_ATTESTATION:
-            return invoke_preclaim<XChainAddClaimAttestation>(ctx);
-        case ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION:
-            return invoke_preclaim<XChainAddAccountCreateAttestation>(ctx);
-        default:
-            assert(false);
-            return temUNKNOWN;
+        // Should never happen
+        JLOG(ctx.j.fatal())
+            << "Unknown transaction type in preclaim: " << e.txnType;
+        assert(false);
+        return temUNKNOWN;
     }
 }
 
 static XRPAmount
 invoke_calculateBaseFee(ReadView const& view, STTx const& tx)
 {
-    switch (tx.getTxnType())
+    try
     {
-        case ttACCOUNT_DELETE:
-            return DeleteAccount::calculateBaseFee(view, tx);
-        case ttACCOUNT_SET:
-            return SetAccount::calculateBaseFee(view, tx);
-        case ttCHECK_CANCEL:
-            return CancelCheck::calculateBaseFee(view, tx);
-        case ttCHECK_CASH:
-            return CashCheck::calculateBaseFee(view, tx);
-        case ttCHECK_CREATE:
-            return CreateCheck::calculateBaseFee(view, tx);
-        case ttDEPOSIT_PREAUTH:
-            return DepositPreauth::calculateBaseFee(view, tx);
-        case ttOFFER_CANCEL:
-            return CancelOffer::calculateBaseFee(view, tx);
-        case ttOFFER_CREATE:
-            return CreateOffer::calculateBaseFee(view, tx);
-        case ttESCROW_CREATE:
-            return EscrowCreate::calculateBaseFee(view, tx);
-        case ttESCROW_FINISH:
-            return EscrowFinish::calculateBaseFee(view, tx);
-        case ttESCROW_CANCEL:
-            return EscrowCancel::calculateBaseFee(view, tx);
-        case ttPAYCHAN_CLAIM:
-            return PayChanClaim::calculateBaseFee(view, tx);
-        case ttPAYCHAN_CREATE:
-            return PayChanCreate::calculateBaseFee(view, tx);
-        case ttPAYCHAN_FUND:
-            return PayChanFund::calculateBaseFee(view, tx);
-        case ttPAYMENT:
-            return Payment::calculateBaseFee(view, tx);
-        case ttREGULAR_KEY_SET:
-            return SetRegularKey::calculateBaseFee(view, tx);
-        case ttSIGNER_LIST_SET:
-            return SetSignerList::calculateBaseFee(view, tx);
-        case ttTICKET_CREATE:
-            return CreateTicket::calculateBaseFee(view, tx);
-        case ttTRUST_SET:
-            return SetTrust::calculateBaseFee(view, tx);
-        case ttAMENDMENT:
-        case ttFEE:
-        case ttUNL_MODIFY:
-            return Change::calculateBaseFee(view, tx);
-        case ttNFTOKEN_MINT:
-            return NFTokenMint::calculateBaseFee(view, tx);
-        case ttNFTOKEN_BURN:
-            return NFTokenBurn::calculateBaseFee(view, tx);
-        case ttNFTOKEN_CREATE_OFFER:
-            return NFTokenCreateOffer::calculateBaseFee(view, tx);
-        case ttNFTOKEN_CANCEL_OFFER:
-            return NFTokenCancelOffer::calculateBaseFee(view, tx);
-        case ttNFTOKEN_ACCEPT_OFFER:
-            return NFTokenAcceptOffer::calculateBaseFee(view, tx);
-        case ttCLAWBACK:
-            return Clawback::calculateBaseFee(view, tx);
-        case ttAMM_CREATE:
-            return AMMCreate::calculateBaseFee(view, tx);
-        case ttAMM_DEPOSIT:
-            return AMMDeposit::calculateBaseFee(view, tx);
-        case ttAMM_WITHDRAW:
-            return AMMWithdraw::calculateBaseFee(view, tx);
-        case ttAMM_VOTE:
-            return AMMVote::calculateBaseFee(view, tx);
-        case ttAMM_BID:
-            return AMMBid::calculateBaseFee(view, tx);
-        case ttAMM_DELETE:
-            return AMMDelete::calculateBaseFee(view, tx);
-        case ttXCHAIN_CREATE_BRIDGE:
-            return XChainCreateBridge::calculateBaseFee(view, tx);
-        case ttXCHAIN_MODIFY_BRIDGE:
-            return BridgeModify::calculateBaseFee(view, tx);
-        case ttXCHAIN_CREATE_CLAIM_ID:
-            return XChainCreateClaimID::calculateBaseFee(view, tx);
-        case ttXCHAIN_COMMIT:
-            return XChainCommit::calculateBaseFee(view, tx);
-        case ttXCHAIN_CLAIM:
-            return XChainClaim::calculateBaseFee(view, tx);
-        case ttXCHAIN_ADD_CLAIM_ATTESTATION:
-            return XChainAddClaimAttestation::calculateBaseFee(view, tx);
-        case ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION:
-            return XChainAddAccountCreateAttestation::calculateBaseFee(
-                view, tx);
-        case ttXCHAIN_ACCOUNT_CREATE_COMMIT:
-            return XChainCreateAccountCommit::calculateBaseFee(view, tx);
-        default:
-            assert(false);
-            return XRPAmount{0};
+        return with_txn_type(tx.getTxnType(), [&]<typename T>() {
+            return T::calculateBaseFee(view, tx);
+        });
+    }
+    catch (UnknownTxnType const& e)
+    {
+        assert(false);
+        return XRPAmount{0};
     }
 }
 
@@ -460,173 +334,20 @@ TxConsequences::TxConsequences(STTx const& tx, std::uint32_t sequencesConsumed)
 static std::pair<TER, bool>
 invoke_apply(ApplyContext& ctx)
 {
-    switch (ctx.tx.getTxnType())
+    try
     {
-        case ttACCOUNT_DELETE: {
-            DeleteAccount p(ctx);
-            return p();
-        }
-        case ttACCOUNT_SET: {
-            SetAccount p(ctx);
-            return p();
-        }
-        case ttCHECK_CANCEL: {
-            CancelCheck p(ctx);
-            return p();
-        }
-        case ttCHECK_CASH: {
-            CashCheck p(ctx);
-            return p();
-        }
-        case ttCHECK_CREATE: {
-            CreateCheck p(ctx);
-            return p();
-        }
-        case ttDEPOSIT_PREAUTH: {
-            DepositPreauth p(ctx);
-            return p();
-        }
-        case ttOFFER_CANCEL: {
-            CancelOffer p(ctx);
-            return p();
-        }
-        case ttOFFER_CREATE: {
-            CreateOffer p(ctx);
-            return p();
-        }
-        case ttESCROW_CREATE: {
-            EscrowCreate p(ctx);
-            return p();
-        }
-        case ttESCROW_FINISH: {
-            EscrowFinish p(ctx);
-            return p();
-        }
-        case ttESCROW_CANCEL: {
-            EscrowCancel p(ctx);
-            return p();
-        }
-        case ttPAYCHAN_CLAIM: {
-            PayChanClaim p(ctx);
-            return p();
-        }
-        case ttPAYCHAN_CREATE: {
-            PayChanCreate p(ctx);
-            return p();
-        }
-        case ttPAYCHAN_FUND: {
-            PayChanFund p(ctx);
-            return p();
-        }
-        case ttPAYMENT: {
-            Payment p(ctx);
-            return p();
-        }
-        case ttREGULAR_KEY_SET: {
-            SetRegularKey p(ctx);
-            return p();
-        }
-        case ttSIGNER_LIST_SET: {
-            SetSignerList p(ctx);
-            return p();
-        }
-        case ttTICKET_CREATE: {
-            CreateTicket p(ctx);
-            return p();
-        }
-        case ttTRUST_SET: {
-            SetTrust p(ctx);
+        return with_txn_type(ctx.tx.getTxnType(), [&]<typename T>() {
+            T p(ctx);
             return p();
-        }
-        case ttAMENDMENT:
-        case ttFEE:
-        case ttUNL_MODIFY: {
-            Change p(ctx);
-            return p();
-        }
-        case ttNFTOKEN_MINT: {
-            NFTokenMint p(ctx);
-            return p();
-        }
-        case ttNFTOKEN_BURN: {
-            NFTokenBurn p(ctx);
-            return p();
-        }
-        case ttNFTOKEN_CREATE_OFFER: {
-            NFTokenCreateOffer p(ctx);
-            return p();
-        }
-        case ttNFTOKEN_CANCEL_OFFER: {
-            NFTokenCancelOffer p(ctx);
-            return p();
-        }
-        case ttNFTOKEN_ACCEPT_OFFER: {
-            NFTokenAcceptOffer p(ctx);
-            return p();
-        }
-        case ttCLAWBACK: {
-            Clawback p(ctx);
-            return p();
-        }
-        case ttAMM_CREATE: {
-            AMMCreate p(ctx);
-            return p();
-        }
-        case ttAMM_DEPOSIT: {
-            AMMDeposit p(ctx);
-            return p();
-        }
-        case ttAMM_WITHDRAW: {
-            AMMWithdraw p(ctx);
-            return p();
-        }
-        case ttAMM_VOTE: {
-            AMMVote p(ctx);
-            return p();
-        }
-        case ttAMM_BID: {
-            AMMBid p(ctx);
-            return p();
-        }
-        case ttAMM_DELETE: {
-            AMMDelete p(ctx);
-            return p();
-        }
-        case ttXCHAIN_CREATE_BRIDGE: {
-            XChainCreateBridge p(ctx);
-            return p();
-        }
-        case ttXCHAIN_MODIFY_BRIDGE: {
-            BridgeModify p(ctx);
-            return p();
-        }
-        case ttXCHAIN_CREATE_CLAIM_ID: {
-            XChainCreateClaimID p(ctx);
-            return p();
-        }
-        case ttXCHAIN_COMMIT: {
-            XChainCommit p(ctx);
-            return p();
-        }
-        case ttXCHAIN_CLAIM: {
-            XChainClaim p(ctx);
-            return p();
-        }
-        case ttXCHAIN_ADD_CLAIM_ATTESTATION: {
-            XChainAddClaimAttestation p(ctx);
-            return p();
-        }
-        case ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION: {
-            XChainAddAccountCreateAttestation p(ctx);
-            return p();
-        }
-        case ttXCHAIN_ACCOUNT_CREATE_COMMIT: {
-            XChainCreateAccountCommit p(ctx);
-            return p();
-        }
-        default:
-            assert(false);
-            return {temUNKNOWN, false};
+        });
+    }
+    catch (UnknownTxnType const& e)
+    {
+        // Should never happen
+        JLOG(ctx.journal.fatal())
+            << "Unknown transaction type in apply: " << e.txnType;
+        assert(false);
+        return {temUNKNOWN, false};
     }
 }
 
diff --git a/src/ripple/net/impl/RPCCall.cpp b/src/ripple/net/impl/RPCCall.cpp
index 1242fdc2a68..b52545960cc 100644
--- a/src/ripple/net/impl/RPCCall.cpp
+++ b/src/ripple/net/impl/RPCCall.cpp
@@ -1194,6 +1194,20 @@ class RPCParser
         return jvRequest;
     }
 
+    // server_definitions [hash]
+    Json::Value
+    parseServerDefinitions(Json::Value const& jvParams)
+    {
+        Json::Value jvRequest{Json::objectValue};
+
+        if (jvParams.size() == 1)
+        {
+            jvRequest[jss::hash] = jvParams[0u].asString();
+        }
+
+        return jvRequest;
+    }
+
     // server_info [counters]
     Json::Value
     parseServerInfo(Json::Value const& jvParams)
@@ -1255,6 +1269,7 @@ class RPCParser
             {"channel_verify", &RPCParser::parseChannelVerify, 4, 4},
             {"connect", &RPCParser::parseConnect, 1, 2},
             {"consensus_info", &RPCParser::parseAsIs, 0, 0},
+            {"crawl_shards", &RPCParser::parseAsIs, 0, 2},
             {"deposit_authorized", &RPCParser::parseDepositAuthorized, 2, 3},
             {"download_shard", &RPCParser::parseDownloadShard, 2, -1},
             {"feature", &RPCParser::parseFeature, 0, 2},
@@ -1292,14 +1307,14 @@ class RPCParser
              1},
             {"peer_reservations_list", &RPCParser::parseAsIs, 0, 0},
             {"ripple_path_find", &RPCParser::parseRipplePathFind, 1, 2},
+            {"server_definitions", &RPCParser::parseServerDefinitions, 0, 1},
+            {"server_info", &RPCParser::parseServerInfo, 0, 1},
+            {"server_state", &RPCParser::parseServerInfo, 0, 1},
             {"sign", &RPCParser::parseSignSubmit, 2, 3},
             {"sign_for", &RPCParser::parseSignFor, 3, 4},
+            {"stop", &RPCParser::parseAsIs, 0, 0},
             {"submit", &RPCParser::parseSignSubmit, 1, 3},
             {"submit_multisigned", &RPCParser::parseSubmitMultiSigned, 1, 1},
-            {"server_info", &RPCParser::parseServerInfo, 0, 1},
-            {"server_state", &RPCParser::parseServerInfo, 0, 1},
-            {"crawl_shards", &RPCParser::parseAsIs, 0, 2},
-            {"stop", &RPCParser::parseAsIs, 0, 0},
             {"transaction_entry", &RPCParser::parseTransactionEntry, 2, 2},
             {"tx", &RPCParser::parseTx, 1, 4},
             {"tx_account", &RPCParser::parseTxAccount, 1, 7},
diff --git a/src/ripple/peerfinder/impl/Logic.h b/src/ripple/peerfinder/impl/Logic.h
index ca14a5111fc..dc325cc480d 100644
--- a/src/ripple/peerfinder/impl/Logic.h
+++ b/src/ripple/peerfinder/impl/Logic.h
@@ -416,10 +416,9 @@ class Logic
         // assert later when erasing the key.
         slot->public_key(key);
         {
-            auto const result = keys_.insert(key);
+            [[maybe_unused]] bool const inserted = keys_.insert(key).second;
             // Public key must not already exist
-            assert(result.second);
-            (void)result.second;
+            assert(inserted);
         }
 
         // Change state and update counts
@@ -434,7 +433,11 @@ class Logic
         if (slot->fixed() && !slot->inbound())
         {
             auto iter(fixed_.find(slot->remote_endpoint()));
-            assert(iter != fixed_.end());
+            if (iter == fixed_.end())
+                LogicError(
+                    "PeerFinder::Logic::activate(): remote_endpoint "
+                    "missing from fixed_");
+
             iter->second.success(m_clock.now());
             JLOG(m_journal.trace()) << beast::leftw(18) << "Logic fixed "
                                     << slot->remote_endpoint() << " success";
@@ -858,7 +861,11 @@ class Logic
         {
             auto const iter = slots_.find(slot->remote_endpoint());
             // The slot must exist in the table
-            assert(iter != slots_.end());
+            if (iter == slots_.end())
+                LogicError(
+                    "PeerFinder::Logic::remove(): remote_endpoint "
+                    "missing from slots_");
+
             // Remove from slot by IP table
             slots_.erase(iter);
         }
@@ -867,7 +874,11 @@ class Logic
         {
             auto const iter = keys_.find(*slot->public_key());
             // Key must exist
-            assert(iter != keys_.end());
+            if (iter == keys_.end())
+                LogicError(
+                    "PeerFinder::Logic::remove(): public_key missing "
+                    "from keys_");
+
             keys_.erase(iter);
         }
         // Remove from connected address table
@@ -875,7 +886,11 @@ class Logic
             auto const iter(
                 connectedAddresses_.find(slot->remote_endpoint().address()));
             // Address must exist
-            assert(iter != connectedAddresses_.end());
+            if (iter == connectedAddresses_.end())
+                LogicError(
+                    "PeerFinder::Logic::remove(): remote_endpont "
+                    "address missing from connectedAddresses_");
+
             connectedAddresses_.erase(iter);
         }
 
@@ -894,7 +909,11 @@ class Logic
         if (slot->fixed() && !slot->inbound() && slot->state() != Slot::active)
         {
             auto iter(fixed_.find(slot->remote_endpoint()));
-            assert(iter != fixed_.end());
+            if (iter == fixed_.end())
+                LogicError(
+                    "PeerFinder::Logic::on_closed(): remote_endpont "
+                    "missing from fixed_");
+
             iter->second.failure(m_clock.now());
             JLOG(m_journal.debug()) << beast::leftw(18) << "Logic fixed "
                                     << slot->remote_endpoint() << " failed";
diff --git a/src/ripple/protocol/Feature.h b/src/ripple/protocol/Feature.h
index df0570d3a52..6377ce3ac62 100644
--- a/src/ripple/protocol/Feature.h
+++ b/src/ripple/protocol/Feature.h
@@ -74,7 +74,7 @@ namespace detail {
 // Feature.cpp. Because it's only used to reserve storage, and determine how
 // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than
 // the actual number of amendments. A LogicError on startup will verify this.
-static constexpr std::size_t numFeatures = 62;
+static constexpr std::size_t numFeatures = 64;
 
 /** Amendments that this server supports and the default voting behavior.
    Whether they are enabled depends on the Rules defined in the validated
@@ -349,6 +349,8 @@ extern uint256 const fixNFTokenRemint;
 extern uint256 const fixReducedOffersV1;
 extern uint256 const featureClawback;
 extern uint256 const featureXChainBridge;
+extern uint256 const fixDisallowIncomingV1;
+extern uint256 const featureDID;
 
 }  // namespace ripple
 
diff --git a/src/ripple/protocol/Indexes.h b/src/ripple/protocol/Indexes.h
index 0c83f7765a4..9a330b6b4f0 100644
--- a/src/ripple/protocol/Indexes.h
+++ b/src/ripple/protocol/Indexes.h
@@ -280,6 +280,9 @@ xChainClaimID(STXChainBridge const& bridge, std::uint64_t seq);
 Keylet
 xChainCreateAccountClaimID(STXChainBridge const& bridge, std::uint64_t seq);
 
+Keylet
+did(AccountID const& account) noexcept;
+
 }  // namespace keylet
 
 // Everything below is deprecated and should be removed in favor of keylets:
diff --git a/src/ripple/protocol/LedgerFormats.h b/src/ripple/protocol/LedgerFormats.h
index e907e299f52..db64942790a 100644
--- a/src/ripple/protocol/LedgerFormats.h
+++ b/src/ripple/protocol/LedgerFormats.h
@@ -186,6 +186,12 @@ enum LedgerEntryType : std::uint16_t
     */
     ltAMM = 0x0079,
 
+    /** The ledger object which tracks the DID.
+
+       \sa keylet::did
+    */
+    ltDID = 0x0049,
+
     //---------------------------------------------------------------------------
     /** A special type, matching any ledger entry type.
 
diff --git a/src/ripple/protocol/Protocol.h b/src/ripple/protocol/Protocol.h
index 6e4879cd746..49642efc4cf 100644
--- a/src/ripple/protocol/Protocol.h
+++ b/src/ripple/protocol/Protocol.h
@@ -83,6 +83,15 @@ std::uint16_t constexpr maxTransferFee = 50000;
 /** The maximum length of a URI inside an NFT */
 std::size_t constexpr maxTokenURILength = 256;
 
+/** The maximum length of a Data element inside a DID */
+std::size_t constexpr maxDIDDocumentLength = 256;
+
+/** The maximum length of a URI inside a DID */
+std::size_t constexpr maxDIDURILength = 256;
+
+/** The maximum length of an Attestation inside a DID */
+std::size_t constexpr maxDIDAttestationLength = 256;
+
 /** The maximum length of a domain */
 std::size_t constexpr maxDomainLength = 256;
 
diff --git a/src/ripple/protocol/SField.h b/src/ripple/protocol/SField.h
index 7c802a64e1d..5d7acb12383 100644
--- a/src/ripple/protocol/SField.h
+++ b/src/ripple/protocol/SField.h
@@ -52,43 +52,65 @@ class STInteger;
 class STXChainBridge;
 class STVector256;
 
-enum SerializedTypeID {
-    // special types
-    STI_UNKNOWN = -2,
-    STI_NOTPRESENT = 0,
-
-    // // types (common)
-    STI_UINT16 = 1,
-    STI_UINT32 = 2,
-    STI_UINT64 = 3,
-    STI_UINT128 = 4,
-    STI_UINT256 = 5,
-    STI_AMOUNT = 6,
-    STI_VL = 7,
-    STI_ACCOUNT = 8,
-    // 9-13 are reserved
-    STI_OBJECT = 14,
-    STI_ARRAY = 15,
-
-    // types (uncommon)
-    STI_UINT8 = 16,
-    STI_UINT160 = 17,
-    STI_PATHSET = 18,
-    STI_VECTOR256 = 19,
-    STI_UINT96 = 20,
-    STI_UINT192 = 21,
-    STI_UINT384 = 22,
-    STI_UINT512 = 23,
-    STI_ISSUE = 24,
-    STI_XCHAIN_BRIDGE = 25,
-
-    // high level types
-    // cannot be serialized inside other types
-    STI_TRANSACTION = 10001,
-    STI_LEDGERENTRY = 10002,
-    STI_VALIDATION = 10003,
-    STI_METADATA = 10004,
-};
+#pragma push_macro("XMACRO")
+#undef XMACRO
+
+#define XMACRO(STYPE)                             \
+    /* special types */                           \
+    STYPE(STI_UNKNOWN, -2)                        \
+    STYPE(STI_NOTPRESENT, 0)                      \
+    STYPE(STI_UINT16, 1)                          \
+                                                  \
+    /* types (common) */                          \
+    STYPE(STI_UINT32, 2)                          \
+    STYPE(STI_UINT64, 3)                          \
+    STYPE(STI_UINT128, 4)                         \
+    STYPE(STI_UINT256, 5)                         \
+    STYPE(STI_AMOUNT, 6)                          \
+    STYPE(STI_VL, 7)                              \
+    STYPE(STI_ACCOUNT, 8)                         \
+                                                  \
+    /* 9-13 are reserved */                       \
+    STYPE(STI_OBJECT, 14)                         \
+    STYPE(STI_ARRAY, 15)                          \
+                                                  \
+    /* types (uncommon) */                        \
+    STYPE(STI_UINT8, 16)                          \
+    STYPE(STI_UINT160, 17)                        \
+    STYPE(STI_PATHSET, 18)                        \
+    STYPE(STI_VECTOR256, 19)                      \
+    STYPE(STI_UINT96, 20)                         \
+    STYPE(STI_UINT192, 21)                        \
+    STYPE(STI_UINT384, 22)                        \
+    STYPE(STI_UINT512, 23)                        \
+    STYPE(STI_ISSUE, 24)                          \
+    STYPE(STI_XCHAIN_BRIDGE, 25)                  \
+                                                  \
+    /* high-level types */                        \
+    /* cannot be serialized inside other types */ \
+    STYPE(STI_TRANSACTION, 10001)                 \
+    STYPE(STI_LEDGERENTRY, 10002)                 \
+    STYPE(STI_VALIDATION, 10003)                  \
+    STYPE(STI_METADATA, 10004)
+
+#pragma push_macro("TO_ENUM")
+#undef TO_ENUM
+#pragma push_macro("TO_MAP")
+#undef TO_MAP
+
+#define TO_ENUM(name, value) name = value,
+#define TO_MAP(name, value) {#name, value},
+
+enum SerializedTypeID { XMACRO(TO_ENUM) };
+
+static std::map<std::string, int> const sTypeMap = {XMACRO(TO_MAP)};
+
+#undef XMACRO
+#undef TO_ENUM
+
+#pragma pop_macro("XMACRO")
+#pragma pop_macro("TO_ENUM")
+#pragma pop_macro("TO_MAP")
 
 // constexpr
 inline int
@@ -266,6 +288,12 @@ class SField
     static int
     compare(const SField& f1, const SField& f2);
 
+    static std::map<int, SField const*> const&
+    getKnownCodeToField()
+    {
+        return knownCodeToField;
+    }
+
 private:
     static int num;
     static std::map<int, SField const*> knownCodeToField;
@@ -524,6 +552,8 @@ extern SF_VL const sfCreateCode;
 extern SF_VL const sfMemoType;
 extern SF_VL const sfMemoData;
 extern SF_VL const sfMemoFormat;
+extern SF_VL const sfDIDDocument;
+extern SF_VL const sfData;
 
 // variable length (uncommon)
 extern SF_VL const sfFulfillment;
diff --git a/src/ripple/protocol/TER.h b/src/ripple/protocol/TER.h
index 4cabac1dd13..23d4fb3ef00 100644
--- a/src/ripple/protocol/TER.h
+++ b/src/ripple/protocol/TER.h
@@ -26,6 +26,7 @@
 #include <optional>
 #include <ostream>
 #include <string>
+#include <unordered_map>
 
 namespace ripple {
 
@@ -132,6 +133,8 @@ enum TEMcodes : TERUnderlyingType {
     temXCHAIN_BRIDGE_NONDOOR_OWNER,
     temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT,
     temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT,
+
+    temEMPTY_DID,
 };
 
 //------------------------------------------------------------------------------
@@ -294,7 +297,7 @@ enum TECcodes : TERUnderlyingType {
     tecKILLED = 150,
     tecHAS_OBLIGATIONS = 151,
     tecTOO_SOON = 152,
-    tecHOOK_ERROR [[maybe_unused]] = 153,
+    tecHOOK_REJECTED [[maybe_unused]] = 153,
     tecMAX_SEQUENCE_REACHED = 154,
     tecNO_SUITABLE_NFTOKEN_PAGE = 155,
     tecNFTOKEN_BUY_SELL_MISMATCH = 156,
@@ -328,6 +331,7 @@ enum TECcodes : TERUnderlyingType {
     tecXCHAIN_SELF_COMMIT = 184,
     tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR = 185,
     tecXCHAIN_CREATE_ACCOUNT_DISABLED = 186,
+    tecEMPTY_DID = 187
 };
 
 //------------------------------------------------------------------------------
@@ -641,6 +645,11 @@ isTecClaim(TER x)
     return ((x) >= tecCLAIM);
 }
 
+std::unordered_map<
+    TERUnderlyingType,
+    std::pair<char const* const, char const* const>> const&
+transResults();
+
 bool
 transResultInfo(TER code, std::string& token, std::string& text);
 
diff --git a/src/ripple/protocol/TxFormats.h b/src/ripple/protocol/TxFormats.h
index d8785f3ea1d..b12547b0a67 100644
--- a/src/ripple/protocol/TxFormats.h
+++ b/src/ripple/protocol/TxFormats.h
@@ -184,6 +184,12 @@ enum TxType : std::uint16_t
     /** This transactions creates a sidechain */
     ttXCHAIN_CREATE_BRIDGE = 48,
 
+    /** This transaction type creates or updates a DID */
+    ttDID_SET = 49,
+
+    /** This transaction type deletes a DID */
+    ttDID_DELETE = 50,
+
 
     /** This system-generated transaction type is used to update the status of the various amendments.
 
diff --git a/src/ripple/protocol/impl/BuildInfo.cpp b/src/ripple/protocol/impl/BuildInfo.cpp
index a0f43df8b64..85659579de6 100644
--- a/src/ripple/protocol/impl/BuildInfo.cpp
+++ b/src/ripple/protocol/impl/BuildInfo.cpp
@@ -33,7 +33,7 @@ namespace BuildInfo {
 //  and follow the format described at http://semver.org/
 //------------------------------------------------------------------------------
 // clang-format off
-char const* const versionString = "2.0.0-b2"
+char const* const versionString = "2.0.0-b3"
 // clang-format on
 
 #if defined(DEBUG) || defined(SANITIZER)
diff --git a/src/ripple/protocol/impl/Feature.cpp b/src/ripple/protocol/impl/Feature.cpp
index aa41b7d5b6e..77a0a9284ac 100644
--- a/src/ripple/protocol/impl/Feature.cpp
+++ b/src/ripple/protocol/impl/Feature.cpp
@@ -456,6 +456,8 @@ REGISTER_FIX    (fixReducedOffersV1,            Supported::yes, VoteBehavior::De
 REGISTER_FEATURE(Clawback,                      Supported::yes, VoteBehavior::DefaultNo);
 REGISTER_FEATURE(AMM,                           Supported::yes, VoteBehavior::DefaultNo);
 REGISTER_FEATURE(XChainBridge,                  Supported::yes, VoteBehavior::DefaultNo);
+REGISTER_FIX    (fixDisallowIncomingV1,         Supported::yes, VoteBehavior::DefaultNo);
+REGISTER_FEATURE(DID,                           Supported::yes, VoteBehavior::DefaultNo);
 
 // The following amendments are obsolete, but must remain supported
 // because they could potentially get enabled.
diff --git a/src/ripple/protocol/impl/Indexes.cpp b/src/ripple/protocol/impl/Indexes.cpp
index 3fef856b365..74f6b6492de 100644
--- a/src/ripple/protocol/impl/Indexes.cpp
+++ b/src/ripple/protocol/impl/Indexes.cpp
@@ -71,6 +71,7 @@ enum class LedgerNameSpace : std::uint16_t {
     BRIDGE = 'H',
     XCHAIN_CLAIM_ID = 'Q',
     XCHAIN_CREATE_ACCOUNT_CLAIM_ID = 'K',
+    DID = 'I',
 
     // No longer used or supported. Left here to reserve the space
     // to avoid accidental reuse.
@@ -437,6 +438,12 @@ xChainCreateAccountClaimID(STXChainBridge const& bridge, std::uint64_t seq)
             seq)};
 }
 
+Keylet
+did(AccountID const& account) noexcept
+{
+    return {ltDID, indexHash(LedgerNameSpace::DID, account)};
+}
+
 }  // namespace keylet
 
 }  // namespace ripple
diff --git a/src/ripple/protocol/impl/LedgerFormats.cpp b/src/ripple/protocol/impl/LedgerFormats.cpp
index e5313a8c1f9..729ddc1c7bc 100644
--- a/src/ripple/protocol/impl/LedgerFormats.cpp
+++ b/src/ripple/protocol/impl/LedgerFormats.cpp
@@ -326,6 +326,19 @@ LedgerFormats::LedgerFormats()
             {sfPreviousTxnLgrSeq,               soeREQUIRED}
         },
         commonFields);
+
+    add(jss::DID,
+        ltDID,
+        {
+            {sfAccount,              soeREQUIRED},
+            {sfDIDDocument,          soeOPTIONAL},
+            {sfURI,                  soeOPTIONAL},
+            {sfData,          soeOPTIONAL},
+            {sfOwnerNode,            soeREQUIRED},
+            {sfPreviousTxnID,        soeREQUIRED},
+            {sfPreviousTxnLgrSeq,    soeREQUIRED}
+        },
+        commonFields);
     // clang-format on
 }
 
diff --git a/src/ripple/protocol/impl/SField.cpp b/src/ripple/protocol/impl/SField.cpp
index 517971dbf07..027c8ffb9c5 100644
--- a/src/ripple/protocol/impl/SField.cpp
+++ b/src/ripple/protocol/impl/SField.cpp
@@ -298,6 +298,8 @@ CONSTRUCT_TYPED_SFIELD(sfHookStateData,         "HookStateData",        VL,
 CONSTRUCT_TYPED_SFIELD(sfHookReturnString,      "HookReturnString",     VL,        23);
 CONSTRUCT_TYPED_SFIELD(sfHookParameterName,     "HookParameterName",    VL,        24);
 CONSTRUCT_TYPED_SFIELD(sfHookParameterValue,    "HookParameterValue",   VL,        25);
+CONSTRUCT_TYPED_SFIELD(sfDIDDocument,           "DIDDocument",          VL,        26);
+CONSTRUCT_TYPED_SFIELD(sfData,                  "Data",                 VL,        27);
 
 // account
 CONSTRUCT_TYPED_SFIELD(sfAccount,               "Account",              ACCOUNT,    1);
diff --git a/src/ripple/protocol/impl/TER.cpp b/src/ripple/protocol/impl/TER.cpp
index 87dae362598..1c2db3feb3b 100644
--- a/src/ripple/protocol/impl/TER.cpp
+++ b/src/ripple/protocol/impl/TER.cpp
@@ -20,13 +20,10 @@
 #include <ripple/protocol/TER.h>
 #include <boost/range/adaptor/transformed.hpp>
 #include <type_traits>
-#include <unordered_map>
 
 namespace ripple {
 
-namespace detail {
-
-static std::unordered_map<
+std::unordered_map<
     TERUnderlyingType,
     std::pair<char const* const, char const* const>> const&
 transResults()
@@ -113,6 +110,7 @@ transResults()
         MAKE_ERROR(tecXCHAIN_SELF_COMMIT,            "Account cannot commit funds to itself."),
         MAKE_ERROR(tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR, "Bad public key account pair in an xchain transaction."),
         MAKE_ERROR(tecXCHAIN_CREATE_ACCOUNT_DISABLED, "This bridge does not support account creation."),
+        MAKE_ERROR(tecEMPTY_DID,                     "The DID object did not have a URI or DIDDocument field."),
 
         MAKE_ERROR(tefALREADY,                     "The exact transaction was already in this ledger."),
         MAKE_ERROR(tefBAD_ADD_AUTH,                "Not authorized to add account."),
@@ -179,6 +177,7 @@ transResults()
         MAKE_ERROR(temBAD_WEIGHT,                "Malformed: Weight must be a positive value."),
         MAKE_ERROR(temDST_IS_SRC,                "Destination may not be source."),
         MAKE_ERROR(temDST_NEEDED,                "Destination not specified."),
+        MAKE_ERROR(temEMPTY_DID,                 "Malformed: No DID data provided."),
         MAKE_ERROR(temINVALID,                   "The transaction is ill-formed."),
         MAKE_ERROR(temINVALID_FLAG,              "The transaction has an invalid flag."),
         MAKE_ERROR(temREDUNDANT,                 "The transaction is redundant."),
@@ -223,12 +222,10 @@ transResults()
     return results;
 }
 
-}  // namespace detail
-
 bool
 transResultInfo(TER code, std::string& token, std::string& text)
 {
-    auto& results = detail::transResults();
+    auto& results = transResults();
 
     auto const r = results.find(TERtoInt(code));
 
@@ -262,7 +259,7 @@ std::optional<TER>
 transCode(std::string const& token)
 {
     static auto const results = [] {
-        auto& byTer = detail::transResults();
+        auto& byTer = transResults();
         auto range = boost::make_iterator_range(byTer.begin(), byTer.end());
         auto tRange = boost::adaptors::transform(range, [](auto const& r) {
             return std::make_pair(r.second.first, r.first);
diff --git a/src/ripple/protocol/impl/TxFormats.cpp b/src/ripple/protocol/impl/TxFormats.cpp
index 755401bda92..7be8ca741e2 100644
--- a/src/ripple/protocol/impl/TxFormats.cpp
+++ b/src/ripple/protocol/impl/TxFormats.cpp
@@ -472,6 +472,17 @@ TxFormats::TxFormats()
             {sfSignatureReward, soeREQUIRED},
         },
         commonFields);
+
+    add(jss::DIDSet,
+        ttDID_SET,
+        {
+            {sfDIDDocument, soeOPTIONAL},
+            {sfURI, soeOPTIONAL},
+            {sfData, soeOPTIONAL},
+        },
+        commonFields);
+
+    add(jss::DIDDelete, ttDID_DELETE, {}, commonFields);
 }
 
 TxFormats const&
diff --git a/src/ripple/protocol/jss.h b/src/ripple/protocol/jss.h
index 9a3e315dd8e..4a8f80b8c7b 100644
--- a/src/ripple/protocol/jss.h
+++ b/src/ripple/protocol/jss.h
@@ -69,6 +69,9 @@ JSS(CheckCash);            // transaction type.
 JSS(CheckCreate);          // transaction type.
 JSS(Clawback);             // transaction type.
 JSS(ClearFlag);            // field.
+JSS(DID);                  // ledger type.
+JSS(DIDDelete);            // transaction type.
+JSS(DIDSet);               // transaction type.
 JSS(DeliverMin);           // in: TransactionSign
 JSS(DepositPreauth);       // transaction and ledger type.
 JSS(Destination);          // in: TransactionSign; field.
@@ -278,6 +281,7 @@ JSS(destination_currencies);  // in: PathRequest, RipplePathFind
 JSS(destination_tag);         // in: PathRequest
                               // out: AccountChannels
 JSS(details);                 // out: Manifest, server_info
+JSS(did);                     // in: LedgerEntry
 JSS(dir_entry);               // out: DirectoryEntryIterator
 JSS(dir_index);               // out: DirectoryEntryIterator
 JSS(dir_root);                // out: DirectoryEntryIterator
@@ -315,8 +319,10 @@ JSS(fee_base);              // out: NetworkOPs
 JSS(fee_div_max);           // in: TransactionSign
 JSS(fee_level);             // out: AccountInfo
 JSS(fee_mult_max);          // in: TransactionSign
-JSS(fee_ref);               // out: NetworkOPs
+JSS(fee_ref);               // out: NetworkOPs, DEPRECATED
 JSS(fetch_pack);            // out: NetworkOPs
+JSS(FIELDS);                // out: RPC server_definitions
+                            // matches definitions.json format
 JSS(first);                 // out: rpc/Version
 JSS(firstSequence);         // out: NodeToShardStatus
 JSS(firstShardIndex);       // out: NodeToShardStatus
@@ -361,6 +367,12 @@ JSS(invalid_API_version);  // out: Many, when a request has an invalid
 JSS(io_latency_ms);        // out: NetworkOPs
 JSS(ip);                   // in: Connect, out: OverlayImpl
 JSS(is_burned);            // out: nft_info (clio)
+JSS(isSerialized);         // out: RPC server_definitions
+                           // matches definitions.json format
+JSS(isSigningField);       // out: RPC server_definitions
+                           // matches definitions.json format
+JSS(isVLEncoded);          // out: RPC server_definitions
+                           // matches definitions.json format
 JSS(issuer);               // in: RipplePathFind, Subscribe,
                            //     Unsubscribe, BookOffers
                            // out: STPathSet, STAmount
@@ -400,6 +412,8 @@ JSS(ledger_index_min);            // in, out: AccountTx*
 JSS(ledger_max);                  // in, out: AccountTx*
 JSS(ledger_min);                  // in, out: AccountTx*
 JSS(ledger_time);                 // out: NetworkOPs
+JSS(LEDGER_ENTRY_TYPES);          // out: RPC server_definitions
+                                  // matches definitions.json format
 JSS(levels);                      // LogLevels
 JSS(limit);                       // in/out: AccountTx*, AccountOffers,
                                   //         AccountLines, AccountObjects
@@ -486,6 +500,7 @@ JSS(node_written_bytes);         // out: GetCounts
 JSS(node_writes_duration_us);    // out: GetCounts
 JSS(node_write_retries);         // out: GetCounts
 JSS(node_writes_delayed);        // out::GetCounts
+JSS(nth);                        // out: RPC server_definitions
 JSS(obligations);                // out: GatewayBalances
 JSS(offer);                      // in: LedgerEntry
 JSS(offers);                     // out: NetworkOPs, AccountOffers, Subscribe
@@ -645,6 +660,12 @@ JSS(transaction);             // in: Tx
 JSS(transaction_hash);        // out: RCLCxPeerPos, LedgerToJson
 JSS(transactions);            // out: LedgerToJson,
                               // in: AccountTx*, Unsubscribe
+JSS(TRANSACTION_RESULTS);     // out: RPC server_definitions
+                              // matches definitions.json format
+JSS(TRANSACTION_TYPES);       // out: RPC server_definitions
+                              // matches definitions.json format
+JSS(TYPES);                   // out: RPC server_definitions
+                              // matches definitions.json format
 JSS(transfer_rate);           // out: nft_info (clio)
 JSS(transitions);             // out: NetworkOPs
 JSS(treenode_cache_size);     // out: GetCounts
@@ -676,7 +697,7 @@ JSS(txr_not_enabled_cnt);     // out: peers with tx reduce-relay disabled count
 JSS(txr_missing_tx_freq);     // out: missing tx frequency average
 JSS(txs);                     // out: TxHistory
 JSS(type);                    // in: AccountObjects
-                              // out: NetworkOPs
+                              // out: NetworkOPs, RPC server_definitions
                               //      OverlayImpl, Logic
 JSS(type_hex);                // out: STPathSet
 JSS(unl);                     // out: UnlList
diff --git a/src/ripple/rpc/handlers/Handlers.h b/src/ripple/rpc/handlers/Handlers.h
index 367e715ce1f..ba93be54513 100644
--- a/src/ripple/rpc/handlers/Handlers.h
+++ b/src/ripple/rpc/handlers/Handlers.h
@@ -127,6 +127,8 @@ doPeerReservationsList(RPC::JsonContext&);
 Json::Value
 doRipplePathFind(RPC::JsonContext&);
 Json::Value
+doServerDefinitions(RPC::JsonContext&);
+Json::Value
 doServerInfo(RPC::JsonContext&);  // for humans
 Json::Value
 doServerState(RPC::JsonContext&);  // for machines
diff --git a/src/ripple/rpc/handlers/LedgerEntry.cpp b/src/ripple/rpc/handlers/LedgerEntry.cpp
index 7f40d3ee3be..baff721cc1f 100644
--- a/src/ripple/rpc/handlers/LedgerEntry.cpp
+++ b/src/ripple/rpc/handlers/LedgerEntry.cpp
@@ -588,6 +588,16 @@ doLedgerEntry(RPC::JsonContext& context)
                 }
             }
         }
+        else if (context.params.isMember(jss::did))
+        {
+            expectedType = ltDID;
+            auto const account =
+                parseBase58<AccountID>(context.params[jss::did].asString());
+            if (!account || account->isZero())
+                jvResult[jss::error] = "malformedAddress";
+            else
+                uNodeIndex = keylet::did(*account).key;
+        }
         else
         {
             if (context.params.isMember("params") &&
diff --git a/src/ripple/rpc/handlers/ServerInfo.cpp b/src/ripple/rpc/handlers/ServerInfo.cpp
index aad3d9988e3..2637c3d51be 100644
--- a/src/ripple/rpc/handlers/ServerInfo.cpp
+++ b/src/ripple/rpc/handlers/ServerInfo.cpp
@@ -22,13 +22,302 @@
 #include <ripple/app/reporting/P2pProxy.h>
 #include <ripple/json/json_value.h>
 #include <ripple/net/RPCErr.h>
+#include <ripple/protocol/LedgerFormats.h>
+#include <ripple/protocol/SField.h>
+#include <ripple/protocol/TER.h>
+#include <ripple/protocol/TxFormats.h>
+#include <ripple/protocol/digest.h>
 #include <ripple/protocol/jss.h>
 #include <ripple/rpc/Context.h>
 #include <ripple/rpc/Role.h>
-#include <ripple/rpc/impl/TransactionSign.h>
+
+#include <boost/algorithm/string.hpp>
+
+#include <unordered_map>
 
 namespace ripple {
 
+namespace detail {
+
+class ServerDefinitions
+{
+private:
+    std::string
+    // translate e.g. STI_LEDGERENTRY to LedgerEntry
+    translate(std::string const& inp);
+
+    uint256 defsHash_;
+    Json::Value defs_;
+
+public:
+    ServerDefinitions();
+
+    bool
+    hashMatches(uint256 hash) const
+    {
+        return defsHash_ == hash;
+    }
+
+    Json::Value const&
+    get() const
+    {
+        return defs_;
+    }
+};
+
+std::string
+ServerDefinitions::translate(std::string const& inp)
+{
+    auto replace = [&](char const* oldStr, char const* newStr) -> std::string {
+        std::string out = inp;
+        boost::replace_all(out, oldStr, newStr);
+        return out;
+    };
+
+    auto contains = [&](char const* s) -> bool {
+        return inp.find(s) != std::string::npos;
+    };
+
+    if (contains("UINT"))
+    {
+        if (contains("256") || contains("160") || contains("128"))
+            return replace("UINT", "Hash");
+        else
+            return replace("UINT", "UInt");
+    }
+
+    std::unordered_map<std::string, std::string> replacements{
+        {"OBJECT", "STObject"},
+        {"ARRAY", "STArray"},
+        {"ACCOUNT", "AccountID"},
+        {"LEDGERENTRY", "LedgerEntry"},
+        {"NOTPRESENT", "NotPresent"},
+        {"PATHSET", "PathSet"},
+        {"VL", "Blob"},
+        {"XCHAIN_BRIDGE", "XChainBridge"},
+    };
+
+    if (auto const& it = replacements.find(inp); it != replacements.end())
+    {
+        return it->second;
+    }
+
+    std::string out;
+    size_t pos = 0;
+    std::string inpToProcess = inp;
+
+    // convert snake_case to CamelCase
+    for (;;)
+    {
+        pos = inpToProcess.find("_");
+        if (pos == std::string::npos)
+            pos = inpToProcess.size();
+        std::string token = inpToProcess.substr(0, pos);
+        if (token.size() > 1)
+        {
+            boost::algorithm::to_lower(token);
+            token.data()[0] -= ('a' - 'A');
+            out += token;
+        }
+        else
+            out += token;
+        if (pos == inpToProcess.size())
+            break;
+        inpToProcess = inpToProcess.substr(pos + 1);
+    }
+    return out;
+};
+
+ServerDefinitions::ServerDefinitions() : defs_{Json::objectValue}
+{
+    // populate SerializedTypeID names and values
+    defs_[jss::TYPES] = Json::objectValue;
+
+    defs_[jss::TYPES]["Done"] = -1;
+    std::map<int32_t, std::string> typeMap{{-1, "Done"}};
+    for (auto const& [rawName, typeValue] : sTypeMap)
+    {
+        std::string typeName =
+            translate(std::string(rawName).substr(4) /* remove STI_ */);
+        defs_[jss::TYPES][typeName] = typeValue;
+        typeMap[typeValue] = typeName;
+    }
+
+    // populate LedgerEntryType names and values
+    defs_[jss::LEDGER_ENTRY_TYPES] = Json::objectValue;
+    defs_[jss::LEDGER_ENTRY_TYPES][jss::Invalid] = -1;
+
+    for (auto const& f : LedgerFormats::getInstance())
+    {
+        defs_[jss::LEDGER_ENTRY_TYPES][f.getName()] = f.getType();
+    }
+
+    // populate SField serialization data
+    defs_[jss::FIELDS] = Json::arrayValue;
+
+    uint32_t i = 0;
+    {
+        Json::Value a = Json::arrayValue;
+        a[0U] = "Generic";
+        Json::Value v = Json::objectValue;
+        v[jss::nth] = 0;
+        v[jss::isVLEncoded] = false;
+        v[jss::isSerialized] = false;
+        v[jss::isSigningField] = false;
+        v[jss::type] = "Unknown";
+        a[1U] = v;
+        defs_[jss::FIELDS][i++] = a;
+    }
+
+    {
+        Json::Value a = Json::arrayValue;
+        a[0U] = "Invalid";
+        Json::Value v = Json::objectValue;
+        v[jss::nth] = -1;
+        v[jss::isVLEncoded] = false;
+        v[jss::isSerialized] = false;
+        v[jss::isSigningField] = false;
+        v[jss::type] = "Unknown";
+        a[1U] = v;
+        defs_[jss::FIELDS][i++] = a;
+    }
+
+    {
+        Json::Value a = Json::arrayValue;
+        a[0U] = "ObjectEndMarker";
+        Json::Value v = Json::objectValue;
+        v[jss::nth] = 1;
+        v[jss::isVLEncoded] = false;
+        v[jss::isSerialized] = true;
+        v[jss::isSigningField] = true;
+        v[jss::type] = "STObject";
+        a[1U] = v;
+        defs_[jss::FIELDS][i++] = a;
+    }
+
+    {
+        Json::Value a = Json::arrayValue;
+        a[0U] = "ArrayEndMarker";
+        Json::Value v = Json::objectValue;
+        v[jss::nth] = 1;
+        v[jss::isVLEncoded] = false;
+        v[jss::isSerialized] = true;
+        v[jss::isSigningField] = true;
+        v[jss::type] = "STArray";
+        a[1U] = v;
+        defs_[jss::FIELDS][i++] = a;
+    }
+
+    {
+        Json::Value a = Json::arrayValue;
+        a[0U] = "taker_gets_funded";
+        Json::Value v = Json::objectValue;
+        v[jss::nth] = 258;
+        v[jss::isVLEncoded] = false;
+        v[jss::isSerialized] = false;
+        v[jss::isSigningField] = false;
+        v[jss::type] = "Amount";
+        a[1U] = v;
+        defs_[jss::FIELDS][i++] = a;
+    }
+
+    {
+        Json::Value a = Json::arrayValue;
+        a[0U] = "taker_pays_funded";
+        Json::Value v = Json::objectValue;
+        v[jss::nth] = 259;
+        v[jss::isVLEncoded] = false;
+        v[jss::isSerialized] = false;
+        v[jss::isSigningField] = false;
+        v[jss::type] = "Amount";
+        a[1U] = v;
+        defs_[jss::FIELDS][i++] = a;
+    }
+
+    for (auto const& [code, f] : ripple::SField::getKnownCodeToField())
+    {
+        if (f->fieldName == "")
+            continue;
+
+        Json::Value innerObj = Json::objectValue;
+
+        uint32_t type = f->fieldType;
+
+        innerObj[jss::nth] = f->fieldValue;
+
+        // whether the field is variable-length encoded
+        // this means that the length is included before the content
+        innerObj[jss::isVLEncoded] =
+            (type == 7U /* Blob       */ || type == 8U /* AccountID  */ ||
+             type == 19U /* Vector256  */);
+
+        // whether the field is included in serialization
+        innerObj[jss::isSerialized] =
+            (type < 10000 && f->fieldName != "hash" &&
+             f->fieldName != "index"); /* hash, index, TRANSACTION,
+                                         LEDGER_ENTRY, VALIDATION, METADATA */
+
+        // whether the field is included in serialization when signing
+        innerObj[jss::isSigningField] = f->shouldInclude(false);
+
+        innerObj[jss::type] = typeMap[type];
+
+        Json::Value innerArray = Json::arrayValue;
+        innerArray[0U] = f->fieldName;
+        innerArray[1U] = innerObj;
+
+        defs_[jss::FIELDS][i++] = innerArray;
+    }
+
+    // populate TER code names and values
+    defs_[jss::TRANSACTION_RESULTS] = Json::objectValue;
+
+    for (auto const& [code, terInfo] : transResults())
+    {
+        defs_[jss::TRANSACTION_RESULTS][terInfo.first] = code;
+    }
+
+    // populate TxType names and values
+    defs_[jss::TRANSACTION_TYPES] = Json::objectValue;
+    defs_[jss::TRANSACTION_TYPES][jss::Invalid] = -1;
+    for (auto const& f : TxFormats::getInstance())
+    {
+        defs_[jss::TRANSACTION_TYPES][f.getName()] = f.getType();
+    }
+
+    // generate hash
+    {
+        const std::string out = Json::FastWriter().write(defs_);
+        defsHash_ = ripple::sha512Half(ripple::Slice{out.data(), out.size()});
+        defs_[jss::hash] = to_string(defsHash_);
+    }
+}
+
+}  // namespace detail
+
+Json::Value
+doServerDefinitions(RPC::JsonContext& context)
+{
+    auto& params = context.params;
+
+    uint256 hash;
+    if (params.isMember(jss::hash))
+    {
+        if (!params[jss::hash].isString() ||
+            !hash.parseHex(params[jss::hash].asString()))
+            return RPC::invalid_field_error(jss::hash);
+    }
+
+    static const detail::ServerDefinitions defs{};
+    if (defs.hashMatches(hash))
+    {
+        Json::Value jv = Json::objectValue;
+        jv[jss::hash] = to_string(hash);
+        return jv;
+    }
+    return defs.get();
+}
+
 Json::Value
 doServerInfo(RPC::JsonContext& context)
 {
diff --git a/src/ripple/rpc/impl/Handler.cpp b/src/ripple/rpc/impl/Handler.cpp
index dd898ee8722..b69d2608b0e 100644
--- a/src/ripple/rpc/impl/Handler.cpp
+++ b/src/ripple/rpc/impl/Handler.cpp
@@ -80,6 +80,7 @@ Handler const handlerArray[]{
     {"channel_verify", byRef(&doChannelVerify), Role::USER, NO_CONDITION},
     {"connect", byRef(&doConnect), Role::ADMIN, NO_CONDITION},
     {"consensus_info", byRef(&doConsensusInfo), Role::ADMIN, NO_CONDITION},
+    {"crawl_shards", byRef(&doCrawlShards), Role::ADMIN, NO_CONDITION},
     {"deposit_authorized",
      byRef(&doDepositAuthorized),
      Role::USER,
@@ -139,17 +140,20 @@ Handler const handlerArray[]{
      Role::ADMIN,
      NO_CONDITION},
     {"ripple_path_find", byRef(&doRipplePathFind), Role::USER, NO_CONDITION},
+    {"server_definitions",
+     byRef(&doServerDefinitions),
+     Role::USER,
+     NO_CONDITION},
+    {"server_info", byRef(&doServerInfo), Role::USER, NO_CONDITION},
+    {"server_state", byRef(&doServerState), Role::USER, NO_CONDITION},
     {"sign", byRef(&doSign), Role::USER, NO_CONDITION},
     {"sign_for", byRef(&doSignFor), Role::USER, NO_CONDITION},
+    {"stop", byRef(&doStop), Role::ADMIN, NO_CONDITION},
     {"submit", byRef(&doSubmit), Role::USER, NEEDS_CURRENT_LEDGER},
     {"submit_multisigned",
      byRef(&doSubmitMultiSigned),
      Role::USER,
      NEEDS_CURRENT_LEDGER},
-    {"server_info", byRef(&doServerInfo), Role::USER, NO_CONDITION},
-    {"server_state", byRef(&doServerState), Role::USER, NO_CONDITION},
-    {"crawl_shards", byRef(&doCrawlShards), Role::ADMIN, NO_CONDITION},
-    {"stop", byRef(&doStop), Role::ADMIN, NO_CONDITION},
     {"transaction_entry", byRef(&doTransactionEntry), Role::USER, NO_CONDITION},
     {"tx", byRef(&doTxJson), Role::USER, NEEDS_NETWORK_CONNECTION},
     {"tx_history", byRef(&doTxHistory), Role::USER, NO_CONDITION},
diff --git a/src/ripple/rpc/impl/RPCHelpers.cpp b/src/ripple/rpc/impl/RPCHelpers.cpp
index f082f8913ca..a9cc0f9fffe 100644
--- a/src/ripple/rpc/impl/RPCHelpers.cpp
+++ b/src/ripple/rpc/impl/RPCHelpers.cpp
@@ -988,7 +988,7 @@ chooseLedgerEntryType(Json::Value const& params)
     std::pair<RPC::Status, LedgerEntryType> result{RPC::Status::OK, ltANY};
     if (params.isMember(jss::type))
     {
-        static constexpr std::array<std::pair<char const*, LedgerEntryType>, 19>
+        static constexpr std::array<std::pair<char const*, LedgerEntryType>, 20>
             types{
                 {{jss::account, ltACCOUNT_ROOT},
                  {jss::amendments, ltAMENDMENTS},
@@ -1009,7 +1009,8 @@ chooseLedgerEntryType(Json::Value const& params)
                  {jss::bridge, ltBRIDGE},
                  {jss::xchain_owned_claim_id, ltXCHAIN_OWNED_CLAIM_ID},
                  {jss::xchain_owned_create_account_claim_id,
-                  ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID}}};
+                  ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID},
+                 {jss::did, ltDID}}};
 
         auto const& p = params[jss::type];
         if (!p.isString())
diff --git a/src/test/app/AccountDelete_test.cpp b/src/test/app/AccountDelete_test.cpp
index 2ec0b876a64..fbd631f444a 100644
--- a/src/test/app/AccountDelete_test.cpp
+++ b/src/test/app/AccountDelete_test.cpp
@@ -148,13 +148,14 @@ class AccountDelete_test : public beast::unit_test::suite
         env.close();
 
         // Give carol a deposit preauthorization, an offer, a ticket,
-        // and a signer list.  Even with all that she's still deletable.
+        // a signer list, and a DID.  Even with all that she's still deletable.
         env(deposit::auth(carol, becky));
         std::uint32_t const carolOfferSeq{env.seq(carol)};
         env(offer(carol, gw["USD"](51), XRP(51)));
         std::uint32_t const carolTicketSeq{env.seq(carol) + 1};
         env(ticket::create(carol, 1));
         env(signers(carol, 1, {{alice, 1}, {becky, 1}}));
+        env(did::setValid(carol));
 
         // Deleting should fail with TOO_SOON, which is a relatively
         // cheap check compared to validating the contents of her directory.
diff --git a/src/test/app/DID_test.cpp b/src/test/app/DID_test.cpp
new file mode 100644
index 00000000000..3aa27978bfe
--- /dev/null
+++ b/src/test/app/DID_test.cpp
@@ -0,0 +1,406 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2012, 2013 Ripple Labs Inc.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include <ripple/basics/strHex.h>
+#include <ripple/protocol/Feature.h>
+#include <ripple/protocol/Indexes.h>
+#include <ripple/protocol/TxFlags.h>
+#include <ripple/protocol/jss.h>
+#include <test/jtx.h>
+
+#include <algorithm>
+#include <iterator>
+
+namespace ripple {
+namespace test {
+
+// Helper function that returns the owner count of an account root.
+std::uint32_t
+ownerCount(test::jtx::Env const& env, test::jtx::Account const& acct)
+{
+    std::uint32_t ret{0};
+    if (auto const sleAcct = env.le(acct))
+        ret = sleAcct->at(sfOwnerCount);
+    return ret;
+}
+
+bool
+checkVL(Slice const& result, std::string expected)
+{
+    Serializer s;
+    s.addRaw(result);
+    return s.getString() == expected;
+}
+
+struct DID_test : public beast::unit_test::suite
+{
+    void
+    testEnabled(FeatureBitset features)
+    {
+        testcase("featureDID Enabled");
+
+        using namespace jtx;
+        // If the DID amendment is not enabled, you should not be able
+        // to set or delete DIDs.
+        Env env{*this, features - featureDID};
+        Account const alice{"alice"};
+        env.fund(XRP(5000), alice);
+        env.close();
+
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+        env(did::setValid(alice), ter(temDISABLED));
+        env.close();
+
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+        env(did::del(alice), ter(temDISABLED));
+        env.close();
+    }
+
+    void
+    testAccountReserve(FeatureBitset features)
+    {
+        // Verify that the reserve behaves as expected for minting.
+        testcase("DID Account Reserve");
+
+        using namespace test::jtx;
+
+        Env env{*this, features};
+        Account const alice{"alice"};
+
+        // Fund alice enough to exist, but not enough to meet
+        // the reserve for creating a DID.
+        auto const acctReserve = env.current()->fees().accountReserve(0);
+        auto const incReserve = env.current()->fees().increment;
+        env.fund(acctReserve, alice);
+        env.close();
+        BEAST_EXPECT(env.balance(alice) == acctReserve);
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+
+        // alice does not have enough XRP to cover the reserve for a DID
+        env(did::setValid(alice), ter(tecINSUFFICIENT_RESERVE));
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+
+        // Pay alice almost enough to make the reserve for a DID.
+        env(pay(env.master, alice, incReserve + drops(19)));
+        BEAST_EXPECT(env.balance(alice) == acctReserve + incReserve + drops(9));
+        env.close();
+
+        // alice still does not have enough XRP for the reserve of a DID.
+        env(did::setValid(alice), ter(tecINSUFFICIENT_RESERVE));
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+
+        // Pay alice enough to make the reserve for a DID.
+        env(pay(env.master, alice, drops(11)));
+        env.close();
+
+        // Now alice can create a DID.
+        env(did::setValid(alice));
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 1);
+
+        // alice deletes her DID.
+        env(did::del(alice));
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+        env.close();
+    }
+
+    void
+    testSetInvalid(FeatureBitset features)
+    {
+        testcase("Invalid DIDSet");
+
+        using namespace jtx;
+        using namespace std::chrono;
+
+        Env env(*this);
+        Account const alice{"alice"};
+        env.fund(XRP(5000), alice);
+        env.close();
+
+        //----------------------------------------------------------------------
+        // preflight
+
+        // invalid flags
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+        env(did::setValid(alice), txflags(0x00010000), ter(temINVALID_FLAG));
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+
+        // no fields
+        env(did::set(alice), ter(temEMPTY_DID));
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+
+        // all empty fields
+        env(did::set(alice),
+            did::uri(""),
+            did::document(""),
+            did::data(""),
+            ter(temEMPTY_DID));
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+
+        // uri is too long
+        const std::string longString(257, 'a');
+        env(did::set(alice), did::uri(longString), ter(temMALFORMED));
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+
+        // document is too long
+        env(did::set(alice), did::document(longString), ter(temMALFORMED));
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+
+        // attestation is too long
+        env(did::set(alice),
+            did::document("data"),
+            did::data(longString),
+            ter(temMALFORMED));
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+
+        // Modifying a DID to become empty is checked in testSetModify
+    }
+
+    void
+    testDeleteInvalid(FeatureBitset features)
+    {
+        testcase("Invalid DIDDelete");
+
+        using namespace jtx;
+        using namespace std::chrono;
+
+        Env env(*this);
+        Account const alice{"alice"};
+        env.fund(XRP(5000), alice);
+        env.close();
+
+        //----------------------------------------------------------------------
+        // preflight
+
+        // invalid flags
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+        env(did::del(alice), txflags(0x00010000), ter(temINVALID_FLAG));
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+
+        //----------------------------------------------------------------------
+        // doApply
+
+        // DID doesn't exist
+        env(did::del(alice), ter(tecNO_ENTRY));
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+    }
+
+    void
+    testSetValidInitial(FeatureBitset features)
+    {
+        testcase("Valid Initial DIDSet");
+
+        using namespace jtx;
+        using namespace std::chrono;
+
+        Env env(*this);
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        Account const charlie{"charlie"};
+        Account const dave{"dave"};
+        Account const edna{"edna"};
+        Account const francis{"francis"};
+        Account const george{"george"};
+        env.fund(XRP(5000), alice, bob, charlie, dave, edna, francis);
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+        BEAST_EXPECT(ownerCount(env, bob) == 0);
+        BEAST_EXPECT(ownerCount(env, charlie) == 0);
+
+        // only URI
+        env(did::set(alice), did::uri("uri"));
+        BEAST_EXPECT(ownerCount(env, alice) == 1);
+
+        // only DIDDocument
+        env(did::set(bob), did::document("data"));
+        BEAST_EXPECT(ownerCount(env, bob) == 1);
+
+        // only Data
+        env(did::set(charlie), did::data("data"));
+        BEAST_EXPECT(ownerCount(env, charlie) == 1);
+
+        // URI + Data
+        env(did::set(dave), did::uri("uri"), did::data("attest"));
+        BEAST_EXPECT(ownerCount(env, dave) == 1);
+
+        // URI + DIDDocument
+        env(did::set(edna), did::uri("uri"), did::document("data"));
+        BEAST_EXPECT(ownerCount(env, edna) == 1);
+
+        // DIDDocument + Data
+        env(did::set(francis), did::document("data"), did::data("attest"));
+        BEAST_EXPECT(ownerCount(env, francis) == 1);
+
+        // URI + DIDDocument + Data
+        env(did::set(george),
+            did::uri("uri"),
+            did::document("data"),
+            did::data("attest"));
+        BEAST_EXPECT(ownerCount(env, george) == 1);
+    }
+
+    void
+    testSetModify(FeatureBitset features)
+    {
+        testcase("Modify DID with DIDSet");
+
+        using namespace jtx;
+        using namespace std::chrono;
+
+        Env env(*this);
+        Account const alice{"alice"};
+        env.fund(XRP(5000), alice);
+        env.close();
+        BEAST_EXPECT(ownerCount(env, alice) == 0);
+        auto const ar = env.le(alice);
+
+        // Create DID
+        std::string const initialURI = "uri";
+        {
+            env(did::set(alice), did::uri(initialURI));
+            BEAST_EXPECT(ownerCount(env, alice) == 1);
+            auto const sleDID = env.le(keylet::did(alice.id()));
+            BEAST_EXPECT(sleDID);
+            BEAST_EXPECT(checkVL((*sleDID)[sfURI], initialURI));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfDIDDocument));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfData));
+        }
+
+        // Try to delete URI, fails because no elements are set
+        {
+            env(did::set(alice), did::uri(""), ter(tecEMPTY_DID));
+            BEAST_EXPECT(ownerCount(env, alice) == 1);
+            auto const sleDID = env.le(keylet::did(alice.id()));
+            BEAST_EXPECT(checkVL((*sleDID)[sfURI], initialURI));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfDIDDocument));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfData));
+        }
+
+        // Set DIDDocument
+        std::string const initialDocument = "data";
+        {
+            env(did::set(alice), did::document(initialDocument));
+            BEAST_EXPECT(ownerCount(env, alice) == 1);
+            auto const sleDID = env.le(keylet::did(alice.id()));
+            BEAST_EXPECT(checkVL((*sleDID)[sfURI], initialURI));
+            BEAST_EXPECT(checkVL((*sleDID)[sfDIDDocument], initialDocument));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfData));
+        }
+
+        // Set Data
+        std::string const initialData = "attest";
+        {
+            env(did::set(alice), did::data(initialData));
+            BEAST_EXPECT(ownerCount(env, alice) == 1);
+            auto const sleDID = env.le(keylet::did(alice.id()));
+            BEAST_EXPECT(checkVL((*sleDID)[sfURI], initialURI));
+            BEAST_EXPECT(checkVL((*sleDID)[sfDIDDocument], initialDocument));
+            BEAST_EXPECT(checkVL((*sleDID)[sfData], initialData));
+        }
+
+        // Remove URI
+        {
+            env(did::set(alice), did::uri(""));
+            BEAST_EXPECT(ownerCount(env, alice) == 1);
+            auto const sleDID = env.le(keylet::did(alice.id()));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfURI));
+            BEAST_EXPECT(checkVL((*sleDID)[sfDIDDocument], initialDocument));
+            BEAST_EXPECT(checkVL((*sleDID)[sfData], initialData));
+        }
+
+        // Remove Data
+        {
+            env(did::set(alice), did::data(""));
+            BEAST_EXPECT(ownerCount(env, alice) == 1);
+            auto const sleDID = env.le(keylet::did(alice.id()));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfURI));
+            BEAST_EXPECT(checkVL((*sleDID)[sfDIDDocument], initialDocument));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfData));
+        }
+
+        // Remove Data + set URI
+        std::string const secondURI = "uri2";
+        {
+            env(did::set(alice), did::uri(secondURI), did::document(""));
+            BEAST_EXPECT(ownerCount(env, alice) == 1);
+            auto const sleDID = env.le(keylet::did(alice.id()));
+            BEAST_EXPECT(checkVL((*sleDID)[sfURI], secondURI));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfDIDDocument));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfData));
+        }
+
+        // Remove URI + set DIDDocument
+        std::string const secondDocument = "data2";
+        {
+            env(did::set(alice), did::uri(""), did::document(secondDocument));
+            BEAST_EXPECT(ownerCount(env, alice) == 1);
+            auto const sleDID = env.le(keylet::did(alice.id()));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfURI));
+            BEAST_EXPECT(checkVL((*sleDID)[sfDIDDocument], secondDocument));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfData));
+        }
+
+        // Remove DIDDocument + set Data
+        std::string const secondData = "randomData";
+        {
+            env(did::set(alice), did::document(""), did::data(secondData));
+            BEAST_EXPECT(ownerCount(env, alice) == 1);
+            auto const sleDID = env.le(keylet::did(alice.id()));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfURI));
+            BEAST_EXPECT(!sleDID->isFieldPresent(sfDIDDocument));
+            BEAST_EXPECT(checkVL((*sleDID)[sfData], secondData));
+        }
+
+        // Delete DID
+        {
+            env(did::del(alice));
+            BEAST_EXPECT(ownerCount(env, alice) == 0);
+            auto const sleDID = env.le(keylet::did(alice.id()));
+            BEAST_EXPECT(!sleDID);
+        }
+    }
+
+    void
+    run() override
+    {
+        using namespace test::jtx;
+        FeatureBitset const all{
+            supported_amendments() | FeatureBitset{featureDID}};
+        testEnabled(all);
+        testAccountReserve(all);
+        testSetInvalid(all);
+        testDeleteInvalid(all);
+        testSetModify(all);
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(DID, app, ripple);
+
+}  // namespace test
+}  // namespace ripple
diff --git a/src/test/app/NFToken_test.cpp b/src/test/app/NFToken_test.cpp
index 0539d2abd93..2f029c5db1f 100644
--- a/src/test/app/NFToken_test.cpp
+++ b/src/test/app/NFToken_test.cpp
@@ -581,7 +581,7 @@ class NFToken0_test : public beast::unit_test::suite
             ter(temMALFORMED));
 
         //----------------------------------------------------------------------
-        // preflight
+        // preclaim
 
         // Non-existent issuer.
         env(token::mint(alice, 0u),
diff --git a/src/test/app/SetTrust_test.cpp b/src/test/app/SetTrust_test.cpp
index fce9c4295c2..599ac1917f9 100644
--- a/src/test/app/SetTrust_test.cpp
+++ b/src/test/app/SetTrust_test.cpp
@@ -275,6 +275,48 @@ class SetTrust_test : public beast::unit_test::suite
             BEAST_EXPECT(!(flags & lsfDisallowIncomingTrustline));
         }
 
+        // fixDisallowIncomingV1
+        {
+            for (bool const withFix : {true, false})
+            {
+                auto const amend = withFix
+                    ? features | disallowIncoming
+                    : (features | disallowIncoming) - fixDisallowIncomingV1;
+
+                Env env{*this, amend};
+                auto const dist = Account("dist");
+                auto const gw = Account("gw");
+                auto const USD = gw["USD"];
+                auto const distUSD = dist["USD"];
+
+                env.fund(XRP(1000), gw, dist);
+                env.close();
+
+                env(fset(gw, asfRequireAuth));
+                env.close();
+
+                env(fset(dist, asfDisallowIncomingTrustline));
+                env.close();
+
+                env(trust(dist, USD(10000)));
+                env.close();
+
+                // withFix: can set trustline
+                // withOutFix: cannot set trustline
+                auto const trustResult =
+                    withFix ? ter(tesSUCCESS) : ter(tecNO_PERMISSION);
+                env(trust(gw, distUSD(10000)),
+                    txflags(tfSetfAuth),
+                    trustResult);
+                env.close();
+
+                auto const txResult =
+                    withFix ? ter(tesSUCCESS) : ter(tecPATH_DRY);
+                env(pay(gw, dist, USD(1000)), txResult);
+                env.close();
+            }
+        }
+
         Env env{*this, features | disallowIncoming};
 
         auto const gw = Account{"gateway"};
diff --git a/src/test/app/TxQ_test.cpp b/src/test/app/TxQ_test.cpp
index 4bc0040f867..ac6bf56f06c 100644
--- a/src/test/app/TxQ_test.cpp
+++ b/src/test/app/TxQ_test.cpp
@@ -4843,13 +4843,13 @@ class TxQ1_test : public beast::unit_test::suite
                     drops[jss::base_fee] == "0");
                 BEAST_EXPECT(
                     drops.isMember(jss::median_fee) &&
-                    drops[jss::base_fee] == "0");
+                    drops[jss::median_fee] == "0");
                 BEAST_EXPECT(
                     drops.isMember(jss::minimum_fee) &&
-                    drops[jss::base_fee] == "0");
+                    drops[jss::minimum_fee] == "0");
                 BEAST_EXPECT(
                     drops.isMember(jss::open_ledger_fee) &&
-                    drops[jss::base_fee] == "0");
+                    drops[jss::open_ledger_fee] == "0");
             }
         }
 
diff --git a/src/test/jtx.h b/src/test/jtx.h
index dd987472cc8..03bbf154e63 100644
--- a/src/test/jtx.h
+++ b/src/test/jtx.h
@@ -35,6 +35,7 @@
 #include <test/jtx/check.h>
 #include <test/jtx/delivermin.h>
 #include <test/jtx/deposit.h>
+#include <test/jtx/did.h>
 #include <test/jtx/fee.h>
 #include <test/jtx/flags.h>
 #include <test/jtx/invoice_id.h>
diff --git a/src/test/jtx/did.h b/src/test/jtx/did.h
new file mode 100644
index 00000000000..0cffb60e527
--- /dev/null
+++ b/src/test/jtx/did.h
@@ -0,0 +1,104 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2019 Ripple Labs Inc.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef RIPPLE_TEST_JTX_DID_H_INCLUDED
+#define RIPPLE_TEST_JTX_DID_H_INCLUDED
+
+#include <test/jtx/Account.h>
+#include <test/jtx/Env.h>
+#include <test/jtx/owners.h>
+
+namespace ripple {
+namespace test {
+namespace jtx {
+
+/** DID operations. */
+namespace did {
+
+Json::Value
+set(jtx::Account const& account);
+
+Json::Value
+setValid(jtx::Account const& account);
+
+/** Sets the optional DIDDocument on a DIDSet. */
+class document
+{
+private:
+    std::string document_;
+
+public:
+    explicit document(std::string const& u) : document_(strHex(u))
+    {
+    }
+
+    void
+    operator()(jtx::Env&, jtx::JTx& jtx) const
+    {
+        jtx.jv[sfDIDDocument.jsonName] = document_;
+    }
+};
+
+/** Sets the optional URI on a DIDSet. */
+class uri
+{
+private:
+    std::string uri_;
+
+public:
+    explicit uri(std::string const& u) : uri_(strHex(u))
+    {
+    }
+
+    void
+    operator()(jtx::Env&, jtx::JTx& jtx) const
+    {
+        jtx.jv[sfURI.jsonName] = uri_;
+    }
+};
+
+/** Sets the optional Attestation on a DIDSet. */
+class data
+{
+private:
+    std::string data_;
+
+public:
+    explicit data(std::string const& u) : data_(strHex(u))
+    {
+    }
+
+    void
+    operator()(jtx::Env&, jtx::JTx& jtx) const
+    {
+        jtx.jv[sfData.jsonName] = data_;
+    }
+};
+
+Json::Value
+del(jtx::Account const& account);
+
+}  // namespace did
+
+}  // namespace jtx
+
+}  // namespace test
+}  // namespace ripple
+
+#endif
diff --git a/src/test/jtx/impl/did.cpp b/src/test/jtx/impl/did.cpp
new file mode 100644
index 00000000000..94dfcc32754
--- /dev/null
+++ b/src/test/jtx/impl/did.cpp
@@ -0,0 +1,67 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2019 Ripple Labs Inc.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include <ripple/protocol/TxFlags.h>
+#include <ripple/protocol/jss.h>
+#include <test/jtx/did.h>
+
+namespace ripple {
+namespace test {
+namespace jtx {
+
+/** DID operations. */
+namespace did {
+
+Json::Value
+set(jtx::Account const& account)
+{
+    Json::Value jv;
+    jv[jss::TransactionType] = jss::DIDSet;
+    jv[jss::Account] = to_string(account.id());
+    jv[jss::Flags] = tfUniversal;
+    return jv;
+}
+
+Json::Value
+setValid(jtx::Account const& account)
+{
+    Json::Value jv;
+    jv[jss::TransactionType] = jss::DIDSet;
+    jv[jss::Account] = to_string(account.id());
+    jv[jss::Flags] = tfUniversal;
+    jv[sfURI.jsonName] = strHex(std::string{"uri"});
+    return jv;
+}
+
+Json::Value
+del(jtx::Account const& account)
+{
+    Json::Value jv;
+    jv[jss::TransactionType] = jss::DIDDelete;
+    jv[jss::Account] = to_string(account.id());
+    jv[jss::Flags] = tfUniversal;
+    return jv;
+}
+
+}  // namespace did
+
+}  // namespace jtx
+
+}  // namespace test
+}  // namespace ripple
diff --git a/src/test/rpc/AccountObjects_test.cpp b/src/test/rpc/AccountObjects_test.cpp
index e38c7c029b7..17217f2c880 100644
--- a/src/test/rpc/AccountObjects_test.cpp
+++ b/src/test/rpc/AccountObjects_test.cpp
@@ -599,6 +599,7 @@ class AccountObjects_test : public beast::unit_test::suite
         BEAST_EXPECT(acct_objs_is_size(acct_objs(gw, jss::state), 0));
         BEAST_EXPECT(acct_objs_is_size(acct_objs(gw, jss::ticket), 0));
         BEAST_EXPECT(acct_objs_is_size(acct_objs(gw, jss::amm), 0));
+        BEAST_EXPECT(acct_objs_is_size(acct_objs(gw, jss::did), 0));
 
         // gw mints an NFT so we can find it.
         uint256 const nftID{token::getNextID(env, gw, 0u, tfTransferable)};
@@ -854,6 +855,26 @@ class AccountObjects_test : public beast::unit_test::suite
             BEAST_EXPECT(
                 payChan[sfSettleDelay.jsonName].asUInt() == 24 * 60 * 60);
         }
+
+        {
+            // gw creates a DID that we can look for in the ledger.
+            Json::Value jvDID;
+            jvDID[jss::TransactionType] = jss::DIDSet;
+            jvDID[jss::Flags] = tfUniversal;
+            jvDID[jss::Account] = gw.human();
+            jvDID[sfURI.jsonName] = strHex(std::string{"uri"});
+            env(jvDID);
+            env.close();
+        }
+        {
+            // Find the DID.
+            Json::Value const resp = acct_objs(gw, jss::did);
+            BEAST_EXPECT(acct_objs_is_size(resp, 1));
+
+            auto const& did = resp[jss::result][jss::account_objects][0u];
+            BEAST_EXPECT(did[sfAccount.jsonName] == gw.human());
+            BEAST_EXPECT(did[sfURI.jsonName] == strHex(std::string{"uri"}));
+        }
         // Make gw multisigning by adding a signerList.
         env(jtx::signers(gw, 6, {{alice, 7}}));
         env.close();
@@ -881,7 +902,7 @@ class AccountObjects_test : public beast::unit_test::suite
             auto const& ticket = resp[jss::result][jss::account_objects][0u];
             BEAST_EXPECT(ticket[sfAccount.jsonName] == gw.human());
             BEAST_EXPECT(ticket[sfLedgerEntryType.jsonName] == jss::Ticket);
-            BEAST_EXPECT(ticket[sfTicketSequence.jsonName].asUInt() == 13);
+            BEAST_EXPECT(ticket[sfTicketSequence.jsonName].asUInt() == 14);
         }
         {
             // See how "deletion_blockers_only" handles gw's directory.
diff --git a/src/test/rpc/LedgerRPC_test.cpp b/src/test/rpc/LedgerRPC_test.cpp
index 960ac3a86ee..2b4d8527a64 100644
--- a/src/test/rpc/LedgerRPC_test.cpp
+++ b/src/test/rpc/LedgerRPC_test.cpp
@@ -1530,6 +1530,57 @@ class LedgerRPC_test : public beast::unit_test::suite
         }
     }
 
+    void
+    testLedgerEntryDID()
+    {
+        testcase("ledger_entry Request DID");
+        using namespace test::jtx;
+        using namespace std::literals::chrono_literals;
+        Env env{*this};
+        Account const alice{"alice"};
+
+        env.fund(XRP(10000), alice);
+        env.close();
+
+        // Lambda to create a DID.
+        auto didCreate = [](test::jtx::Account const& account) {
+            Json::Value jv;
+            jv[jss::TransactionType] = jss::DIDSet;
+            jv[jss::Account] = account.human();
+            jv[sfDIDDocument.jsonName] = strHex(std::string{"data"});
+            jv[sfURI.jsonName] = strHex(std::string{"uri"});
+            return jv;
+        };
+
+        env(didCreate(alice));
+        env.close();
+
+        std::string const ledgerHash{to_string(env.closed()->info().hash)};
+
+        {
+            // Request the DID using its index.
+            Json::Value jvParams;
+            jvParams[jss::did] = alice.human();
+            jvParams[jss::ledger_hash] = ledgerHash;
+            Json::Value const jrr = env.rpc(
+                "json", "ledger_entry", to_string(jvParams))[jss::result];
+            BEAST_EXPECT(
+                jrr[jss::node][sfDIDDocument.jsonName] ==
+                strHex(std::string{"data"}));
+            BEAST_EXPECT(
+                jrr[jss::node][sfURI.jsonName] == strHex(std::string{"uri"}));
+        }
+        {
+            // Request an index that is not a DID.
+            Json::Value jvParams;
+            jvParams[jss::did] = env.master.human();
+            jvParams[jss::ledger_hash] = ledgerHash;
+            Json::Value const jrr = env.rpc(
+                "json", "ledger_entry", to_string(jvParams))[jss::result];
+            checkErrorValue(jrr, "entryNotFound", "");
+        }
+    }
+
     void
     testLedgerEntryInvalidParams(unsigned int apiVersion)
     {
@@ -2252,6 +2303,7 @@ class LedgerRPC_test : public beast::unit_test::suite
         testNoQueue();
         testQueue();
         testLedgerAccountsOption();
+        testLedgerEntryDID();
 
         test::jtx::forAllApiVersions(std::bind_front(
             &LedgerRPC_test::testLedgerEntryInvalidParams, this));
diff --git a/src/test/rpc/ServerInfo_test.cpp b/src/test/rpc/ServerInfo_test.cpp
index a69483cb130..1d78f1cc36b 100644
--- a/src/test/rpc/ServerInfo_test.cpp
+++ b/src/test/rpc/ServerInfo_test.cpp
@@ -79,6 +79,8 @@ admin = 127.0.0.1
     void
     testServerInfo()
     {
+        testcase("server_info");
+
         using namespace test::jtx;
 
         {
@@ -148,10 +150,104 @@ admin = 127.0.0.1
         }
     }
 
+    void
+    testServerDefinitions()
+    {
+        testcase("server_definitions");
+
+        using namespace test::jtx;
+
+        {
+            Env env(*this);
+            auto const result = env.rpc("server_definitions");
+            BEAST_EXPECT(!result[jss::result].isMember(jss::error));
+            BEAST_EXPECT(result[jss::result][jss::status] == "success");
+            BEAST_EXPECT(result[jss::result].isMember(jss::FIELDS));
+            BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
+            BEAST_EXPECT(
+                result[jss::result].isMember(jss::TRANSACTION_RESULTS));
+            BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_TYPES));
+            BEAST_EXPECT(result[jss::result].isMember(jss::TYPES));
+            BEAST_EXPECT(result[jss::result].isMember(jss::hash));
+
+            // test a random element of each result
+            // (testing the whole output would be difficult to maintain)
+
+            {
+                auto const firstField = result[jss::result][jss::FIELDS][0u];
+                BEAST_EXPECT(firstField[0u].asString() == "Generic");
+                BEAST_EXPECT(
+                    firstField[1][jss::isSerialized].asBool() == false);
+                BEAST_EXPECT(
+                    firstField[1][jss::isSigningField].asBool() == false);
+                BEAST_EXPECT(firstField[1][jss::isVLEncoded].asBool() == false);
+                BEAST_EXPECT(firstField[1][jss::nth].asUInt() == 0);
+                BEAST_EXPECT(firstField[1][jss::type].asString() == "Unknown");
+            }
+
+            BEAST_EXPECT(
+                result[jss::result][jss::LEDGER_ENTRY_TYPES]["AccountRoot"]
+                    .asUInt() == 97);
+            BEAST_EXPECT(
+                result[jss::result][jss::TRANSACTION_RESULTS]["tecDIR_FULL"]
+                    .asUInt() == 121);
+            BEAST_EXPECT(
+                result[jss::result][jss::TRANSACTION_TYPES]["Payment"]
+                    .asUInt() == 0);
+            BEAST_EXPECT(
+                result[jss::result][jss::TYPES]["AccountID"].asUInt() == 8);
+        }
+
+        // test providing the same hash
+        {
+            Env env(*this);
+            auto const firstResult = env.rpc("server_definitions");
+            auto const hash = firstResult[jss::result][jss::hash].asString();
+            auto const hashParam =
+                std::string("{ ") + "\"hash\": \"" + hash + "\"}";
+
+            auto const result =
+                env.rpc("json", "server_definitions", hashParam);
+            BEAST_EXPECT(!result[jss::result].isMember(jss::error));
+            BEAST_EXPECT(result[jss::result][jss::status] == "success");
+            BEAST_EXPECT(!result[jss::result].isMember(jss::FIELDS));
+            BEAST_EXPECT(
+                !result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
+            BEAST_EXPECT(
+                !result[jss::result].isMember(jss::TRANSACTION_RESULTS));
+            BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_TYPES));
+            BEAST_EXPECT(!result[jss::result].isMember(jss::TYPES));
+            BEAST_EXPECT(result[jss::result].isMember(jss::hash));
+        }
+
+        // test providing a different hash
+        {
+            Env env(*this);
+            std::string const hash =
+                "54296160385A27154BFA70A239DD8E8FD4CC2DB7BA32D970BA3A5B132CF749"
+                "D1";
+            auto const hashParam =
+                std::string("{ ") + "\"hash\": \"" + hash + "\"}";
+
+            auto const result =
+                env.rpc("json", "server_definitions", hashParam);
+            BEAST_EXPECT(!result[jss::result].isMember(jss::error));
+            BEAST_EXPECT(result[jss::result][jss::status] == "success");
+            BEAST_EXPECT(result[jss::result].isMember(jss::FIELDS));
+            BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
+            BEAST_EXPECT(
+                result[jss::result].isMember(jss::TRANSACTION_RESULTS));
+            BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_TYPES));
+            BEAST_EXPECT(result[jss::result].isMember(jss::TYPES));
+            BEAST_EXPECT(result[jss::result].isMember(jss::hash));
+        }
+    }
+
     void
     run() override
     {
         testServerInfo();
+        testServerDefinitions();
     }
 };