feat: Send asynchronous messages as notifications from API version 3

A message a subscription pushes is one the server sends unprompted, which
the specification shapes as a notification: an object naming the protocol
and the method, the content under `params`, and no `id`. It is sent today as
a bare object with `type` naming the event, so it is neither a response nor
a notification. From API version 3 the value of `type` becomes the `method`
and the rest becomes `params`. A message naming no `type` has nothing to
dispatch on and is passed through.

The publisher shapes, not the subscriber. Every publish site sends through
`sendShaped`, which takes the version the publisher read from the
subscription's own map entry, so the shape and the content follow one value;
a sink holds no version to read.

A `path_find` update is a notification too, since `path_find create` already
consumed the one response the specification allows, and the `id` that
correlates it travels inside `params`. The `account_history` failure message
names no `type`, so a version 3 client cannot classify it; `stampStreamError`
names the stream it concerns on a copy made only for a subscriber a
notification is built for, and a gtest pins it. A subscriber named by a url
is the exception at every version: its transport puts what it is given
inside an `event` request, so a notification would arrive nested in a
request, and `wantsNotifications` answers no.

.cspell.config.yaml

@@ -103,7 +103,6 @@ words:
   - dearmor
   - decryptor
   - dedented
-  - dedup
   - deleteme
   - demultiplexer
   - deserializaton
@@ -318,6 +317,7 @@ words:
   - sttx
   - stvar
   - stvector
+  - stxchainattestations
   - summands
   - superpeer
   - superpeers
@@ -344,7 +344,6 @@ words:
   - unambiguity
   - unauthorizes
   - unauthorizing
-  - undeserializable
   - unergonomic
   - unfetched
   - unfindable
@@ -376,6 +375,7 @@ words:
   - writeme
   - wsrch
   - wthread
+  - xbridge
   - xchain
   - xcrun
   - ximinez

.github/dependabot.yml

@@ -36,18 +36,3 @@ updates:
       rust-dependencies:
         patterns:
           - "*"
-
-  - package-ecosystem: uv
-    directory: /cmake/scripts/codegen
-    schedule:
-      interval: weekly
-      day: monday
-      time: "04:00"
-      timezone: Etc/GMT
-    commit-message:
-      prefix: "chore: [DEPENDABOT] "
-    target-branch: develop
-    groups:
-      codegen-dependencies:
-        patterns:
-          - "*"

.github/scripts/levelization/results/ordering.txt

@@ -62,7 +62,6 @@ libxrpl.tx > xrpl.protocol
 libxrpl.tx > xrpl.server
 libxrpl.tx > xrpl.tx
 test.app > test.jtx
-test.app > tests.libxrpl
 test.app > test.unit_test
 test.app > xrpl.basics
 test.app > xrpl.config
@@ -175,8 +174,10 @@ test.server > xrpl.basics
 test.server > xrpl.config
 test.server > xrpld.app
 test.server > xrpld.core
+test.server > xrpld.rpc
 test.server > xrpl.json
 test.server > xrpl.protocol
+test.server > xrpl.resource
 test.server > xrpl.server
 test.unit_test > xrpl.basics
 test.unit_test > xrpl.protocol

.github/workflows/cargo-audit.yml

@@ -8,7 +8,6 @@ on:
     branches:
       - "develop"
       - "release/*"
-      - "staging/*"
     paths:
       - "crates/**/Cargo.toml"
       - "crates/Cargo.lock"

.github/workflows/on-pr.yml

@@ -243,7 +243,7 @@ jobs:
       - should-run
       - build-test
     # Only run when committing to a PR that targets a release branch.
-    if: ${{ github.repository == 'XRPLF/rippled' && needs.should-run.outputs.go == 'true' && github.event_name == 'pull_request' && startsWith(github.event.pull_request.base.ref, 'release/') }}
+    if: ${{ github.repository == 'XRPLF/rippled' && needs.should-run.outputs.go == 'true' && github.event_name == 'pull_request' && startsWith(github.event.pull_request.base.ref, 'release') }}
     uses: ./.github/workflows/reusable-upload-recipe.yml
     secrets:
       remote_username: ${{ secrets.NEXUS_REMOTE_USERNAME }}

.github/workflows/on-trigger.yml

@@ -1,16 +1,14 @@
 # This workflow runs all workflows to build and test the code on various Linux
 # flavors, as well as on MacOS and Windows, on a scheduled basis, on merge into
-# the 'develop', 'release/*' or 'staging/*' branches, or when requested
-# manually. Upon pushes to the develop branch, it also uploads the libxrpl
-# recipe to the Conan remote.
+# the 'develop' or 'release*' branches, or when requested manually. Upon pushes
+# to the develop branch it also uploads the libxrpl recipe to the Conan remote.
 name: Trigger
 
 on:
   push:
     branches:
       - "develop"
-      - "release/*"
-      - "staging/*"
+      - "release*"
     paths:
       # These paths are unique to `on-trigger.yml`.
       - ".github/workflows/on-trigger.yml"
@@ -64,9 +62,9 @@ on:
   workflow_dispatch:
 
 concurrency:
-  # When a PR is merged into the develop branch, it will be assigned a unique
+  # When a PR is merged into the develop branch it will be assigned a unique
   # group identifier, so execution will continue even if another PR is merged
-  # while it is still running. In all other cases, the group identifier is shared
+  # while it is still running. In all other cases the group identifier is shared
   # per branch, so that any in-progress runs are cancelled when a new commit is
   # pushed.
   group: ${{ github.workflow }}-${{ github.event_name == 'push' && github.ref == 'refs/heads/develop' && github.sha || github.ref }}
@@ -100,7 +98,7 @@ jobs:
       # However, we do not enable ccache for events targeting a release branch,
       # to protect against the rare case that the output produced by ccache is
       # not identical to a regular compilation.
-      ccache_enabled: ${{ github.repository_owner == 'XRPLF' && !startsWith(github.ref, 'refs/heads/release/') }}
+      ccache_enabled: ${{ github.repository_owner == 'XRPLF' && !startsWith(github.ref, 'refs/heads/release') }}
       os: ${{ matrix.os }}
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/pre-commit.yml

@@ -8,8 +8,7 @@ on:
   push:
     branches:
       - "develop"
-      - "release/*"
-      - "staging/*"
+      - "release*"
   workflow_dispatch:
 
 jobs:

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

@@ -123,19 +123,13 @@ jobs:
 
       - name: Fix style
         if: ${{ steps.files_changed.outcome != 'success' }}
-        # pre-commit installs every hook's environment, even for hooks that match
-        # no files, and node-based hooks need libatomic, which this image lacks.
-        # Exit code 1 just means hooks modified files or found issues.
-        env:
-          SKIP: prettier,cspell
         run: |
-          git add --update
-          pre-commit run || [ $? -eq 1 ]
+          pre-commit run --all-files || true
 
       - name: Generate git diff
         if: ${{ steps.files_changed.outcome != 'success' }}
         run: |
-          git diff HEAD | tee "${DIFF_FILE}"
+          git diff | tee "${DIFF_FILE}"
 
       - name: Upload clang-tidy diff output
         if: ${{ github.event.repository.visibility == 'public' && steps.files_changed.outcome != 'success' }}

.github/workflows/reusable-package-test-install.yml

@@ -95,15 +95,11 @@ jobs:
           apt-get update -qq
           apt-get install -y "./${PACKAGE}"
 
-      # Rocky Linux and AlmaLinux pick a mirror from a mirrorlist, and now and
-      # then get one that serves the repository metadata at a few hundred kB/s,
-      # which alone outlasts the job's timeout. dnf only abandons a mirror below
-      # 1000 B/s for 30 s, so raise that floor to fail over to the next one fast.
       - name: Install the RPM
         if: ${{ inputs.package_type == 'rpm' }}
         env:
           PACKAGE: ${{ steps.find.outputs.package }}
-        run: dnf install -y --setopt=minrate=1M --setopt=timeout=10 "./${PACKAGE}"
+        run: dnf install -y "./${PACKAGE}"
 
       - name: Run xrpld
         run: xrpld --version

API-CHANGELOG.md

@@ -14,6 +14,8 @@ For a log of breaking changes, see the **API Version [number]** headings. In gen
 
 API version 3 is currently a beta API. It requires enabling `[beta_rpc_api]` in the xrpld configuration to use. See [API-VERSION-3.md](API-VERSION-3.md) for the full list of changes in API version 3.
 
+From this version a message a subscription pushes over WebSocket is sent as a JSON-RPC 2.0 notification: `method` names the event where `type` did, the message's content sits under `params`, and there is no `id`. A `path_find` update is sent the same way. A subscriber named by a `url` receives the legacy `event` call at every version. See [API-VERSION-3.md](API-VERSION-3.md).
+
 ## API Version 2
 
 API version 2 is available in `xrpld` version 2.0.0 and later. See [API-VERSION-2.md](API-VERSION-2.md) for the full list of changes in API version 2.
@@ -22,14 +24,41 @@ API version 2 is available in `xrpld` version 2.0.0 and later. See [API-VERSION-
 
 This version is supported by all `xrpld` versions. For WebSocket and HTTP JSON-RPC requests, it is currently the default API version used when no `api_version` is specified.
 
+## Unreleased
+
+### Breaking changes
+
+- The `ripplerpc` request field, which selects the shape of the JSON-RPC reply envelope, is now validated, and a value that is not exactly `"1.0"`, `"2.0"` or `"3.0"` is rejected. Two things it does not reach: a WebSocket session, which reads the field only to echo it back, and API version 3, where the field selects nothing and so is neither read nor checked, `ripplerpc: "banana"` and no `ripplerpc` at all being served alike. A request sending `"2"`, `" 2.0"`, `"2.00"`, `"02.0"`, `"2.0.0"`, `"10.0"` or any other text, such as `"abc"` or `"x2"`, gets a working reply today. After this ships, such a request sent alone gets HTTP 400 with `ripplerpc is not a supported version`, charged as a malformed request, and such an entry of a `"method": "batch"` body gets that error in its own reply while the batch answers 200. A client that spells the version loosely must therefore be corrected to one of the three exact values, or omit the field. Previously the value was compared as a string, which both accepted values that name no version and ordered multi-digit versions incorrectly: `"abc"` and `"x2"` sorted above `"3.0"` and so selected version 3, and `"10.0"` sorted below `"2.0"` and so selected version 1. Requests that send one of the three supported values, or omit the field, are unaffected.
+- `subscribe`: every subscription a connection holds must name the same `api_version`. The first `subscribe` establishes it, and a later one naming a different version is refused with `apiVersionConflict`, registering nothing; the message names the version the connection's subscriptions are served at. The HTTP status is 400 where the envelope derives it from the error, with `ripplerpc: "3.0"` or at API version 3, and 200 with `ripplerpc` `"1.0"` or `"2.0"`, as for every error; a WebSocket frame carries no status. A `subscribe` refused for another reason, a stream name the server does not have for one, still fixes that version, since the registrations it makes are spread through the handler. A connection that subscribed one stream at `api_version` 2 and another at 1, in two calls, was previously served both at version 1, the later call's, so the first stream's shape changed under it. The version is fixed for the connection's life: a client that wants another version opens another connection. On the webhook path the subscriber is keyed on its `url` alone, so the refusal reaches a second admin because of a first admin's version, and the message names the version the url's subscriptions are served at, and no remedy: releasing a url means unsubscribing its streams, which would remove that first admin's subscription, and the server cannot tell the two callers apart. Naming the url alone does not release it, a subscriber a stream map still holds not being evicted. This reaches every API version, since version 1 and version 2 content is not interchangeable either: version 2 renames `transaction` to `tx_json` and hoists `hash`, so a version 1 client handed version 2 content finds no `transaction` member.
+- `batch`: An entry of a `"method": "batch"` request that names `api_version` both inside `params` and at its own top level is now served at the version inside `params`. It was previously served at the top-level version whenever the one inside `params` resolved to version 1, so an entry asking for version 1 explicitly and something else at the top level changes which version answers it. A lone request can name both values too, and for it the version inside `params` has always won; reversing that precedence was confined to a batch entry.
+- `batch`: every entry of one batch request is now served at the same API version. An entry may name the version the body names, or name none and inherit it, and a body whose entries name two different versions is refused whole with `Batch entries name different versions` at HTTP 400, charged as a malformed request. **This is visible to a version 1 or 2 client:** a `"method": "batch"` body could mix versions across its entries, each entry being dispatched at its own, and the difference is observable because the reply shape changes with the version. Three bodies change. One whose entries name two different versions is now refused instead of answered. One where some entries name a version and others name none now serves all of them at the named version, where an entry naming none was served at version 1; the same applies to a version named on the request's own top level, which the entries now inherit. One whose top level names a version and whose entries name a different one is now refused, where the top-level value was ignored and each entry was served at the version it named. A body whose top level names no version or the same version as its entries, and whose entries agree with one another or name none at all, is unaffected. A `"method": "batch"` body naming at its own top level a version the server does not serve is refused with `invalid_API_version` at HTTP 400, where it was previously served at version 1 as if it had named none. No test pinned the mixing behavior and the line that produced it was a fallback about where the field sits rather than a decision that entries may differ, so this is a correction rather than a removal of a feature: a per-entry version made the entry cap above unanswerable, since a cap can only ask about a body that has one version.
+
+### Additions
+
+- A JSON-RPC (HTTP) request may send its parameters as an object, `"params": {"account": "r..."}`, as well as the array of one object that was already accepted. This reaches every API version: such a request was previously rejected with HTTP 400 and `params unparsable`, and is now served. A request that already sends the array form is unaffected. An entry of a `"method": "batch"` request that carries a by-name `params` object is read for `api_version` and credentials from that object. Previously such an entry had its `api_version` read from its top level and its credentials ignored, since credentials were read only from an array-form `params`.
+- A JSON-RPC (HTTP) request may name its `api_version` at its own top level, beside `method` and `id`, as well as inside `params`. The member is an XRPL extension, which the JSON-RPC 2.0 specification does not define; placing it beside the specification's own members is what lets a version 3 client send a specification-shaped request. This is honored from API version 3 up, so it needs `[beta_rpc_api]`; a version below that named at the top level is ignored, exactly as it always has been. Previously only an entry of a `"method": "batch"` request had its own top level read; a WebSocket request, which is one flat object, has always been read there.
+
+### Bugfixes
+
+- A request echoed back in an error reply now has every credential-bearing field masked: `admin_password`, `admin_user`, `passphrase`, `password`, `secret`, `seed`, `seed_hex`, `url_password`, `url_username` and `username`. Nesting no longer matters, so a credential inside `params` is masked too. The same masking is applied to every request and reply written to the log, and it covers six further names that only a reply carries: `master_key`, `master_seed`, `master_seed_hex`, `validation_key`, `validation_private_key` and `validation_seed`, which is how `wallet_propose` and `validation_create` used to write a live private key to the log. A request or reply written to the log is truncated at 10,000 characters. An `[rpc_startup]` line that does not parse is reported by its position in the section and the parser's message, never by its text, and no command runs for it.
+- The command line client no longer prints a credential the operator did not type. A failing command echoes the request it built under `request_sent`, which carries the `admin_password` the client copies out of `[port_rpc]` in the config, so `./xrpld account_info rBogus` printed that password to stdout and into any captured output. `request_sent` is now masked. The `rpc` member beside it, which echoes the arguments as they were typed, is unchanged. The command line client also no longer writes an unparsed `json` or `ripple_path_find` argument to its trace log before parsing it, where a `secret` inside that argument could not be masked; it logs the parsed request instead, masked. The reply it receives is logged the same way, parsed and masked, where the raw body was written before, a `validation_create` answer included.
+- A WebSocket frame that does not parse, or exceeds the request size limit, is answered `{"type": "error", "error": "jsonInvalid", "size": <bytes>}`. The frame's body is reported by size rather than echoed back in a `value` member, since a body that does not parse has no fields to mask. A client that read `value` gets `size` instead.
+- Four error codes that named no HTTP status of their own, and so answered 200 on a reply reporting an error, now name one: `actMalformed`, `alreadyMultisig` and `alreadySingleSig` answer 400, and `actNotFound` answers 404. **Only API version 3 reports these four.** A request sending `ripplerpc: "3.0"` at API version 1 or 2 still receives 200 for all four, as it always has, so `account_info` on a malformed account or one the ledger does not hold answers 200 for those clients exactly as before.
+- `submit`, `simulate`, `transaction_entry`, `ledger_entry` and `ledger_accept`: Errors from these methods now include `error_code` and `error_message` alongside the `error` token, as every other method already did. Each error now answers the status its code names: 400 for a malformed request, 404 for `transactionNotFound`, 500 for an internal failure, and 501 for `notYetImplemented` and `notStandAlone`. That status change reaches only a request sending `ripplerpc: "3.0"`, or API version 3, which are the envelopes that derive the status from the error. With `ripplerpc` `"1.0"` the status stays 200 and the two new members appear beside `error`; with `"2.0"` the status stays 200, `error_code` appears, and the `code` and `message` members carry the code and the message rather than null, since that envelope copies them from `error_code` and `error_message` and drops `error_message`. From API version 3 the twenty-one `malformed*` tokens `ledger_entry` names each report the code they own instead of 31.
+- A reply reporting HTTP 402 or 502 now carries a status line. Those two statuses named no case in the switch that writes one, so such a reply began with a header instead and did not parse as an HTTP response at all. Both are reachable at any API version with `ripplerpc: "3.0"`, which derives the status from the error code: 402 through `highFee` from `sign`, `sign_for` or `submit` with a low `fee_mult_max`, and 502 through `dbDeserialization` from `tx`. The eleven statuses that already named a case report the same phrase they always have.
+- An error reply to a request sending `ripplerpc: "2.0"` or `"3.0"` no longer carries a stray `"error_message": null` beside the error it reports. The member appeared only when the `Server` log partition was set to debug or lower, because the log statement read `error_message` after the reply had renamed it to `message`, and reading it put it back as null. So the reply a client received depended on the server's log level, and the log line itself printed an empty message. Both are fixed.
+- A body the server rejects before it reads a request out of it now says what was wrong. A body over the size limit answers `Request is too large`, and a body that parses to `{}` or `null` answers `Request is empty`; both previously answered `Unable to parse request: ` with nothing after the colon, the parser having recorded no error for them. Any other body that is not an array does not parse, which includes one that is only whitespace and one whose top-level value is a string, number or boolean; it answers `Unable to parse request: ` followed by the parser's own reason, as it did before. The status is 400 for all three, as before, and this reaches every API version. A top-level array, the one other body nothing can read a request from, is answered with a JSON error object instead, which the entry on top-level arrays below describes.
+- `batch`: An entry that is not identified through a secure gateway no longer clears the connection's `X-User` and forwarded-for values for the entries after it, so every entry of one body reports the role and username it would have reported on its own.
+- `batch`: Every entry of a `"method": "batch"` request is now charged against the sender's resource allowance, including one rejected before it reaches a handler, and the request stops at the first entry the connection is too loaded to serve. A reply array can therefore be shorter than the request array, and its last element depends on where the batch stopped. An entry that is not a JSON object, or names an API version the server does not serve, is charged before its role is known and answered with its own rejection; if that charge took the connection over the drop threshold, the batch stops there and that rejection is the last answer. Every other entry met over the threshold is answered `Server is overloaded` and nothing follows. A client should read any reply array shorter than its request as a connection over the drop threshold, whatever the last element says. A well-behaved client is unaffected; one that sends thousands of entries in a single body no longer gets every one of them answered.
+- A body the server rejects before it reads a request out of it is now charged against the sender's resource allowance, as a malformed request already was. Ten conditions were free: a body over the size limit, one that does not parse, one carrying no document, one that is neither a JSON object nor an array, a `"method": "batch"` naming no entry array, and six ways a top-level array is not a batch this server can serve. The answer to the first five is unchanged; an array's answer changes as the entry on top-level arrays below describes, the one generic rejection it received having become six. A well-behaved client is unaffected; one that repeats such a body exhausts its allowance and is refused the next request a handler would have served. A WebSocket frame that does not parse, or exceeds the request size limit, is charged the same way, and a connection that sends only such frames is closed once it crosses the drop threshold.
+- `subscribe`, `path_find`: A subscription is now served at the API version its own `subscribe` call named, rather than at the version of the most recent `subscribe` or `path_find` on the same connection. A `path_find` no longer changes the version anything that connection has subscribed is served at. An ordinary request is unaffected: it names its own version and is answered at it, so a connection subscribed at `api_version` 3 still calls `account_info` at version 1 and reads the version 1 shape.
+- `batch`: A batch request served at API version 3 or above is now refused when it holds more than 100 entries, before any entry is dispatched. The cap reads the one version the body is served at, so no ordering of the entries evades it. A body served below version 3 is unaffected and stays bounded only by the request size limit.
+- A top-level JSON array, which is the JSON-RPC 2.0 batch form accepted from API version 3, is now rejected with a JSON-RPC error object rather than a plain text body when it cannot be served: when it is empty, holds more than 100 entries, holds nothing that could be a request, names no API version of 3 or above that the server serves, or names two different versions the server serves. An array naming no served version of 3 or above is refused for requiring version 3, or, where every version it names is one the server does not serve, with `invalid_API_version`. One entry naming a version the server does not serve does not reject an array in which another entry names a served version: it is answered on its own, inside the reply array, with the same `-32606` code. This reaches every API version, since no earlier version accepts an array at all: a client that sent one received HTTP 400 with `Unable to parse request: ` and now receives the same status with a JSON body. The message also names the version rather than the shape where the version is what is wrong, which is what a client with `[beta_rpc_api]` disabled receives.
+
 ## XRP Ledger server version 3.5.0
 
 Version 3.5.0 is not yet released.
 
-### Breaking changes in 3.5.0
-
-- The `XChainBridge` amendment and its ledger entries and transactions are removed. `XChainBridge` and `fixXChainRewardRounding` are now obsolete and can no longer be voted for; neither was ever enabled on Mainnet. `ledger_entry` no longer accepts `bridge`, `xchain_owned_claim_id`, or `xchain_owned_create_account_claim_id`; `account_objects` no longer accepts those values in `type`; and `server_definitions` no longer lists the removed ledger entry types, transaction types, fields, and the `XChainBridge` serialized type.
-
 ### Additions in 3.5.0
 
 - `subscribe`, `unsubscribe`: Added an optional `mpt_issuances` request field, an array of MPT issuance IDs (hex strings). Subscribers receive the same `transaction` message as the `transactions` stream for each validated transaction whose metadata affects a subscribed issuance. MPT issuance subscriptions count toward the per-connection subscription limit. An empty array, a non-array value, or an invalid ID returns `invalidParams`. ([#5671](https://github.com/XRPLF/rippled/pull/5671))
@@ -39,11 +68,6 @@ Version 3.5.0 is not yet released.
 
 - `channel_authorize`: The `channel_id` field now returns an `invalidParams` error if the value is not a string. [#7582](https://github.com/XRPLF/rippled/pull/7582)
 - `channel_verify`: The `channel_id` and `signature` fields now return an `invalidParams` error if the value is not a string. [#7582](https://github.com/XRPLF/rippled/pull/7582)
-- `account_currencies`, `account_nfts`, `account_offers`: A request with more than one problem may now report a different one of them. An invalid `ledger_hash` or `ledger_index` is reported before an invalid or missing `account`. An invalid `limit` or `marker` is reported before `lgrNotFound` or `actNotFound`, and for `account_offers` also before `actMalformed`. A request with a single problem returns the same error as before. [#8561](https://github.com/XRPLF/rippled/pull/8561)
-- `deposit_authorized`: A `credentials` entry that is all zeros (for example `"0"` or 64 `0` characters) now returns a `badCredentials` error instead of looking up a credential that can never exist.
-- `account_info`, `account_lines`, `account_channels`: A request with more than one problem may now report a different one of them. An invalid `ledger_hash` or `ledger_index` is reported before a missing or invalid `account`, or `ident` for `account_info`. For `account_lines`, a `peer` that is not a string, or an invalid `limit` or `marker`, is reported before `lgrNotFound`, `actNotFound` or a malformed `account`, and an invalid `limit` or `marker` also before a malformed `peer`. For `account_channels`, a malformed `account` is reported before `lgrNotFound`, and an invalid `destination_account`, `limit` or `marker` before `lgrNotFound` or `actNotFound`. A request with a single problem returns the same error as before. [#8573](https://github.com/XRPLF/rippled/pull/8573)
-- `deposit_authorized`, `nft_buy_offers`, `nft_sell_offers`: A request with more than one problem may now report a different one of them. An invalid `ledger_hash` or `ledger_index` is reported before a missing or invalid `source_account`, `destination_account` or `nft_id`, and for `nft_buy_offers` / `nft_sell_offers` also before an invalid `limit`. For `deposit_authorized`, an invalid `credentials` array is reported before `lgrNotFound`, `srcActNotFound`, `dstActNotFound` or `badCredentials`. For `nft_buy_offers` and `nft_sell_offers`, an invalid `marker` is reported before `lgrNotFound` or `objectNotFound`. A request with a single problem returns the same error as before. [#8613](https://github.com/XRPLF/rippled/pull/8613)
-- `nft_buy_offers`, `nft_sell_offers`: An `nft_id` that is an array or an object now returns an `invalidParams` error instead of an `internal` error. [#8613](https://github.com/XRPLF/rippled/pull/8613)
 
 ### Bugfixes in 3.5.0
 

BUILD.md

@@ -2,12 +2,33 @@
 | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | These instructions assume you have a C++ development environment ready with Git, Python, Conan, CMake, and a C++ compiler. For help setting one up on Linux, macOS, or Windows, [see this guide](./docs/build/environment.md).<br><br>These instructions also assume a basic familiarity with Conan and CMake. If you are unfamiliar with Conan, you can read our [crash course](./docs/build/conan.md) or the official [Getting Started][conan-getting-started] walkthrough. |
 
-## Supported platforms
+## Minimum Requirements
 
-Building and testing are supported on Linux, macOS, and (best effort) Windows;
-see [Supported development platforms](./docs/build/environment.md#supported-development-platforms).
-Running `xrpld` is officially supported on Linux only;
-see [Requirements](./docs/install.md#requirements).
+For the hardware needed to run a node, see
+[System Requirements](https://xrpl.org/system-requirements.html).
+
+For the software needed to build xrpld, see the
+[environment setup guide](./docs/build/environment.md).
+
+## Operating Systems
+
+### Linux
+
+The Ubuntu Linux distribution has received the highest level of quality
+assurance, testing, and support. We also support Red Hat and use Debian
+internally.
+Our Linux CI tooling is distro-independent and uses a Nix-based environment, so it should be possible to build on other Linux distributions as well, although we have not tested them.
+
+### macOS
+
+Many `xrpld` engineers use macOS for development.
+The minimum supported version is macOS 15 (Sequoia).
+CI testing is done in macOS 26 (Tahoe), but the build defaults `CMAKE_OSX_DEPLOYMENT_TARGET` to 15.
+
+### Windows
+
+Windows is used by some engineers for development only, and is not recommended
+for production use.
 
 ## Steps
 

CMakeLists.txt

@@ -42,7 +42,7 @@ if(is_gcc)
     # GCC-specific fixes
     add_compile_options(-Wno-unknown-pragmas -Wno-subobject-linkage)
     # -Wno-subobject-linkage can be removed when we upgrade GCC version to at least 13.3
-elseif(is_any_clang)
+elseif(is_clang)
     # Clang-specific fixes
     add_compile_options(-Wno-unknown-warning-option) # Ignore unknown warning options
 elseif(is_msvc)

CONTRIBUTING.md

@@ -332,7 +332,7 @@ This ensures that configuration changes don't introduce new warnings across the
 
 ### Installing clang-tidy
 
-The [Nix development shell](./docs/build/nix.md) provides `clang-tidy` at the [tested version](./docs/build/environment.md#tested-compiler-versions).
+See the [environment setup guide](./docs/build/environment.md#clang-tidy) for how to get clang-tidy.
 
 ### Running clang-tidy locally
 

RELEASING.md

@@ -34,7 +34,7 @@ so tools can filter them and protection rules can target `release/*` and `stagin
 - **Branches only move forward.**
   `develop`, `staging/X.Y.x`, and `release/X.Y.x` are never rewritten.
 - **Cherry-picking only goes from `develop` to a staging branch**,
-  for fixes that must get into a release after the [code freeze](#release-candidates)
+  for fixes that must get into a release after the code freeze
   (see [Emergency Fixes From `develop`](#emergency-fixes-from-develop)).
 - **Security fixes are prepared privately and published with the release that contains them**,
   so vulnerabilities are not disclosed prematurely.
@@ -49,7 +49,6 @@ develop                            staging/X.Y.x & release/X.Y.x
    │
    ├── Tag: X.Y.0-b1
    ├── Tag: X.Y.0-bN
-   │  (2 weeks before rc1: freeze on large changes starts)
    ├── Tag: X.Y.0-rc1 ───────────────┐ (branches created)
    │                                 │
    │  (development continues)        ├── Fixes
@@ -76,20 +75,16 @@ develop                            staging/X.Y.x & release/X.Y.x
 3. **Branches:** `staging/X.Y.x` and `release/X.Y.x` are created from `develop`
    at the commit tagged `X.Y.0-rc1`.
    The first RC also kicks off the QE process.
-
-### Freeze on Large Changes
-
-From two weeks before `X.Y.0-rc1` until `X.Y.0` is [merged back](#merging-back-into-develop),
-large changes (e.g., big refactors, moving or renaming many files, mass reformatting)
-are not merged into `develop`.
+4. **Code freeze:** No new features or unrelated changes are pulled from `develop`
+   into `staging/X.Y.x` or `release/X.Y.x`.
+   Only critical stabilization fixes go into the line.
+5. **No large changes on `develop`:** Until `X.Y.0` is [merged back](#merging-back-into-develop),
+   large changes (e.g., big refactors, moving or renaming many files, mass reformatting)
+   are not merged into `develop`,
+   so that fixes on the line and the merge back don't run into conflicts.
 
 ### Release Candidates
 
-After branching, the line is in code freeze:
-no new features or unrelated changes are pulled from `develop`
-into `staging/X.Y.x` or `release/X.Y.x`.
-Only critical stabilization fixes go into the line.
-
 1. Fixes are developed against `staging/X.Y.x`.
 2. When ready, a new RC is created on `staging/X.Y.x`,
    and `release/X.Y.x` is fast-forwarded to it.
@@ -111,8 +106,7 @@ one right after the other.
 2. `release/X.Y.x` is fast-forwarded to `staging/X.Y.x`,
    and the release is tagged on it.
 3. The release is immediately [merged back into `develop`](#merging-back-into-develop).
-   For a major-minor release, this lifts the [freeze on large changes](#freeze-on-large-changes)
-   in `develop`.
+   For a major-minor release, this lifts the freeze on large changes in `develop`.
 
 ### Merging Back Into `develop`
 
@@ -133,7 +127,7 @@ After the merge, `git log develop..<tag>` must be empty.
 ### Emergency Fixes From `develop`
 
 If a commit was merged to `develop`
-and needs to be included in a release after the [code freeze](#release-candidates):
+and needs to be included in a release after the code freeze:
 
 1. Create a PR that cherry-picks the commit onto `staging/X.Y.x`.
 2. Leave `develop` as it is, with no reverts.

cfg/xrpld-example.cfg

@@ -1360,39 +1360,6 @@
 #       Example:
 #           owner_reserve = 200000      # 0.2 XRP
 #
-#   gas_limit = <gas>
-#
-#       The gas limit is the maximum amount of gas that can be
-#       consumed by a single transaction. The gas limit is used to prevent
-#       transactions from consuming too many resources.
-#
-#       If this parameter is unspecified, xrpld will use an internal
-#       default. Don't change this without understanding the consequences.
-#
-#       Example:
-#           gas_limit = 1000000      # 1 million gas
-#
-#   bytecode_size_limit = <bytes>
-#
-#       The bytecode size limit is the maximum size of a WASM extension in
-#       bytes. The size limit is used to prevent extensions from consuming
-#       too many resources.
-#
-#       If this parameter is unspecified, xrpld will use an internal
-#       default. Don't change this without understanding the consequences.
-#
-#       Example:
-#           bytecode_size_limit = 100000      # 100 kb
-#
-#   gas_price = <micro-drops>
-#
-#       The gas price is the conversion between WASM gas and its price in drops.
-#
-#       If this parameter is unspecified, xrpld will use an internal
-#       default. Don't change this without understanding the consequences.
-#
-#       Example:
-#           gas_price = 1000000      # 1 drop per gas
 #-------------------------------------------------------------------------------
 #
 # 9. Misc Settings

cmake/CompilationEnv.cmake

@@ -9,21 +9,13 @@ include_guard(GLOBAL)
 # --------------------------------------------------------------------
 # Compiler detection (C++)
 # --------------------------------------------------------------------
-# is_any_clang is true for both LLVM Clang and AppleClang. Their version numbers
-# and feature sets differ, so use is_llvm_clang or is_apple_clang when it matters.
-set(is_any_clang FALSE)
-set(is_llvm_clang FALSE)
-set(is_apple_clang FALSE)
+set(is_clang FALSE)
 set(is_gcc FALSE)
 set(is_msvc FALSE)
 set(is_xcode FALSE)
 
-if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    set(is_any_clang TRUE)
-    set(is_llvm_clang TRUE)
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
-    set(is_any_clang TRUE)
-    set(is_apple_clang TRUE)
+if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang") # Clang or AppleClang
+    set(is_clang TRUE)
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(is_gcc TRUE)
 elseif(MSVC)

cmake/XrplCompiler.cmake

@@ -130,7 +130,7 @@ else()
         INTERFACE
             -Wall
             -Wdeprecated
-            $<$<BOOL:${is_any_clang}>:-Wno-deprecated-declarations>
+            $<$<BOOL:${is_clang}>:-Wno-deprecated-declarations>
             $<$<BOOL:${wextra}>:-Wextra
             -Wno-unused-parameter>
             $<$<BOOL:${werr}>:-Werror>
@@ -177,7 +177,7 @@ else()
     if(
         is_nix_compiler
         AND is_linux
-        AND is_any_clang
+        AND is_clang
         AND CMAKE_CXX_FLAGS MATCHES "stdlib=libstdc"
     )
         string(
@@ -204,10 +204,7 @@ if(voidstar)
             "Antithesis instrumentation requires Linux, aborting..."
         )
     elseif(
-        NOT (
-            is_llvm_clang
-            AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0
-        )
+        NOT (is_clang AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0)
     )
         message(
             FATAL_ERROR

cmake/XrplCore.cmake

@@ -296,18 +296,7 @@ if(xrpld)
         OUT_VAR rpcspec_instantiations
         VALUE_TYPE "::json::Value"
         VIEW_HEADER "xrpld/rpc/detail/JsonObjectView.hpp"
-        HANDLERS
-            account_channels
-            account_currencies
-            account_info
-            account_lines
-            account_nfts
-            account_offers
-            book_changes
-            deposit_authorized
-            ledger
-            nft_offers_common
-            transaction_entry
+        HANDLERS book_changes ledger transaction_entry
     )
     target_sources(xrpld PRIVATE ${rpcspec_instantiations})
 

cmake/XrplSanitizers.cmake

@@ -58,7 +58,7 @@ target_link_options(common INTERFACE ${sanitizers_linker_flags})
 # This module appends -fsanitize-ignorelist=<path> for Clang builds.
 # The ignorelist path contains CMAKE_SOURCE_DIR, so it must be set here, rather than in the Conan profile.
 # GCC does not support -fsanitize-ignorelist.
-if(is_any_clang)
+if(is_clang)
     set(ignorelist_path
         "${CMAKE_SOURCE_DIR}/sanitizers/suppressions/sanitizer-ignorelist.txt"
     )

cmake/XrplSanity.cmake

@@ -23,8 +23,11 @@ if(NOT is_multiconfig)
     endif()
 endif()
 
-if(is_llvm_clang)
-    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0)
+if(is_clang) # both Clang and AppleClang
+    if(
+        "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"
+        AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0
+    )
         message(FATAL_ERROR "This project requires clang 16 or later")
     endif()
 elseif(is_gcc)

cmake/XrplSettings.cmake

@@ -62,11 +62,11 @@ if(unity)
     set(CMAKE_UNITY_BUILD ON CACHE BOOL "Do a unity build")
 endif()
 
-if(is_llvm_clang AND is_linux)
+if(is_clang AND is_linux)
     option(voidstar "Enable Antithesis instrumentation." OFF)
 endif()
 
-if(is_gcc OR is_any_clang)
+if(is_gcc OR is_clang)
     include(ProcessorCount)
     ProcessorCount(PROCESSOR_COUNT)
 
@@ -125,7 +125,7 @@ else()
     set(use_mold OFF CACHE BOOL "mold linker, linux only" FORCE)
 endif()
 
-if(is_any_clang)
+if(is_clang)
     option(use_lld "enables detection of lld linker" ON)
 else()
     set(use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)

cmake/scripts/codegen/requirements.in

@@ -7,7 +7,7 @@
 pcpp>=1.30
 
 # Parser combinator library - used to parse the macro DSL
-pyparsing>=3.3.3
+pyparsing>=3.0.0
 
 # Template engine - used to generate C++ code from templates
-Mako>=1.4.2
+Mako>=1.2.2

cmake/scripts/codegen/requirements.txt

@@ -1,8 +1,8 @@
 # This file was autogenerated by uv via the following command:
 #    uv pip compile requirements.in --generate-hashes --output-file requirements.txt
-mako==1.4.3 \
-    --hash=sha256:723296007c870bfd6b3f0c3230dba7198096e5269297ebf5e4eff9e7ffa39d4f \
-    --hash=sha256:cd6537fe88d5fec315c55c2f8529bc4ce7a9a352ad7db3eeaa6a66e2dd4ec37a
+mako==1.3.12 \
+    --hash=sha256:8f61569480282dbf557145ce441e4ba888be453c30989f879f0d652e39f53ea9 \
+    --hash=sha256:9f778e93289bd410bb35daadeb4fc66d95a746f0b75777b942088b7fd7af550a
     # via -r requirements.in
 markupsafe==3.0.3 \
     --hash=sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f \
@@ -99,7 +99,7 @@ pcpp==1.30 \
     --hash=sha256:05fe08292b6da57f385001c891a87f40d6aa7f46787b03e8ba326d20a3297c6e \
     --hash=sha256:5af9fbce55f136d7931ae915fae03c34030a3b36c496e72d9636cedc8e2543a1
     # via -r requirements.in
-pyparsing==3.3.3 \
-    --hash=sha256:928ae7e20211f3b6f3915a72f06a0cfd29ab9d24279dd6346b6b1a7146397d36 \
-    --hash=sha256:ece8c00a69cf01b45d0b1dedabb469c90d8caf996d4fda40f147627a122849a4
+pyparsing==3.3.2 \
+    --hash=sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d \
+    --hash=sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc
     # via -r requirements.in

conan.lock

@@ -3,11 +3,11 @@
     "requires": [
         "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1782392402.122708",
         "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1782392402.420688",
-        "xrpl-rpc-spec/0.1.29#852afc87cac32aca93cc50a985d73fe0%1792359643.19817",
+        "xrpl-rpc-spec/0.1.21#d536f87a2ae7d313452746cfa3ac4404%1790869005.122975",
         "sqlite3/3.53.0#324ada52333108388a9a6108bfa96734%1782392403.185447",
         "soci/4.0.3#e726491a03468795453f7c83fc924a96%1782392402.679521",
         "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1782307151.633168",
-        "secp256k1/0.7.1#f4d16a4d907dd057598954476ca6f88c%1792234329.790275",
+        "secp256k1/0.7.1#b1f450b7f78a36fff75bb6934a356f3a%1782338841.3729",
         "rocksdb/10.5.1#4a197eca381a3e5ae8adf8cffa5aacd0%1782392413.075713",
         "re2/20251105#8579cfd0bda4daf0683f9e3898f964b4%1782392402.431897",
         "protobuf/6.33.5#ff253ead763bd8d9904a52979cd21e81%1782392410.233933",

conanfile.py

@@ -40,7 +40,7 @@ class Xrpl(ConanFile):
         "nudb/2.0.9",
         "openssl/3.6.3",
         "soci/4.0.3",
-        "xrpl-rpc-spec/0.1.29",
+        "xrpl-rpc-spec/0.1.21",
         "zlib/1.3.2",
     ]
 

docs/build/environment.md

@@ -4,18 +4,6 @@ This document explains how to set one up.
 
 [BUILD.md]: ../../BUILD.md
 
-## Supported development platforms
-
-- **Linux**: the [Nix development shell](./nix.md),
-  which provides the same toolchain CI uses on any distribution.
-- **macOS** 15 (Sequoia) or newer: the [Nix development shell](./nix.md),
-  or the system [Apple Clang](#macos-apple-clang).
-  CI runs on macOS 26 (Tahoe), but the build defaults `CMAKE_OSX_DEPLOYMENT_TARGET` to 15.
-- **Windows**: best effort, see [Windows](#windows).
-
-For the platforms supported for running `xrpld`,
-see [Requirements](../install.md#requirements).
-
 ## Tested compiler versions
 
 `xrpld` is built in the **C++23** dialect by default, so your toolchain has to
@@ -47,16 +35,20 @@ compiler building. Treat support for anything outside the table as best-effort.
 
 ## Required tools
 
-Besides a compiler, building `xrpld` requires
-[Git](https://git-scm.com/downloads),
-[Python](https://www.python.org/downloads/),
-[Conan](https://conan.io/downloads.html),
-and [CMake](https://cmake.org/download/).
-Building with `-Drust=ON` additionally requires a Rust toolchain,
-see [Rust](#rust).
+Besides a compiler, building `xrpld` requires:
+
+| Tool                                        | Minimum version |
+| ------------------------------------------- | --------------- |
+| [Git](https://git-scm.com/downloads)        | any recent      |
+| [Python](https://www.python.org/downloads/) | 3.11            |
+| [Conan](https://conan.io/downloads.html)    | 2.17            |
+| [CMake](https://cmake.org/download/)        | 3.16            |
 
 On Linux and macOS, the [Nix development shell](./nix.md) provides all of them
-at the versions CI uses, recorded in [`nix/check-tools/`](../../nix/check-tools).
+(see below). On Windows they have to be installed manually.
+
+Building with `-Drust=ON` additionally requires a Rust toolchain, see
+[Rust](#rust). A default build does not, so it is not in the table above.
 
 Once they are in place, verify that everything is installed and runnable with:
 
@@ -66,19 +58,60 @@ Once they are in place, verify that everything is installed and runnable with:
 
 ## Linux and macOS
 
-Use the [Nix development shell](./nix.md):
-it provides the compiler and every tool CI uses,
-without installing anything system-wide.
+The **recommended way** to get a development environment on Linux and macOS is
+the Nix development shell. It provides the exact tooling used in CI — `git`,
+`python`, `conan`, `cmake`, `clang-tidy`, `clang-format`, and everything else —
+with a single command and without installing anything system-wide:
 
-### macOS: Apple Clang
+```bash
+nix --experimental-features 'nix-command flakes' develop
+```
 
-You can also build with the system Apple Clang,
-installing the other [required tools](#required-tools) any way you like
-(or getting them from `nix develop .#apple-clang`).
-Its version is whatever your installed Xcode (or Command Line Tools) provides,
-so check that `clang --version` is at least the [tested one](#tested-compiler-versions).
-If several Xcode versions are installed,
-select one with `sudo xcode-select -s <path>` or the `DEVELOPER_DIR` environment variable.
+On **Linux**, Nix also provides the compiler (GCC); on **macOS**, it provides
+Clang. If you instead opt to use your system-wide Apple Clang (via
+`nix develop .#apple-clang`), you need to manage its version yourself (see
+below).
+
+See [Using the Nix development shell](./nix.md) for installation and usage
+details, including how to select a different compiler and why we recommend Nix
+over a hand-maintained environment.
+
+### macOS: managing the Apple Clang version
+
+If you use your system-wide Apple Clang on macOS (via `nix develop .#apple-clang`),
+the compiler version is whatever your installed Xcode (or Command Line Tools)
+provides. The following command should return a version greater than or equal to
+the [tested one](#tested-compiler-versions):
+
+```bash
+clang --version
+```
+
+If you develop other applications using Xcode, you might be consistently
+updating to the newest version of Apple Clang, which will likely cause issues
+building xrpld. You may want to install and pin a specific version of Xcode:
+
+1. **Download Xcode**
+   - Visit [Apple Developer Downloads](https://developer.apple.com/download/more/)
+   - Sign in with your Apple Developer account
+   - Search for an Xcode version that includes the expected Apple Clang version
+   - Download the `.xip` file
+
+2. **Install and configure Xcode**
+
+   ```bash
+   # Extract the .xip file and rename for version management
+   # Example: Xcode_16.2.app
+
+   # Move to Applications directory
+   sudo mv Xcode_16.2.app /Applications/
+
+   # Set as default toolchain (persistent)
+   sudo xcode-select -s /Applications/Xcode_16.2.app/Contents/Developer
+
+   # Set as environment variable (temporary)
+   export DEVELOPER_DIR=/Applications/Xcode_16.2.app/Contents/Developer
+   ```
 
 ## Windows
 
@@ -90,7 +123,8 @@ manually:
   "x64 Native Tools Command Prompt". CI configures CMake with the
   `Visual Studio 18 2026` generator.
 - [Git for Windows](https://git-scm.com/download/win)
-- recent releases of Python, Conan, and CMake
+- Python, Conan, and CMake, at the versions listed in
+  [Required tools](#required-tools).
 - a [Rust toolchain](https://rustup.rs) — only needed to build with
   `-Drust=ON`, see [Rust](#rust)
 
@@ -111,5 +145,16 @@ version.
 Everything else the Rust build needs on the CMake side comes from Conan along
 with the rest of the dependencies, so there is nothing further to install.
 
+## Clang-tidy
+
+`clang-tidy` is required to run static analysis checks locally (see
+[CONTRIBUTING.md](../../CONTRIBUTING.md)). It is not required to build the
+project. The version this project uses is listed in
+[Tested compiler versions](#tested-compiler-versions).
+
+On Linux and macOS, the [Nix development shell](./nix.md) provides that exact
+version out of the box — run it via `run-clang-tidy`. No separate installation
+is needed.
+
 [cpp23-support]: https://en.cppreference.com/w/cpp/compiler_support/23
 [packages.nix]: ../../nix/packages.nix

docs/build/nix.md

@@ -9,7 +9,9 @@ This guide explains how to use Nix to set up a reproducible development environm
 - **Reproducible environment**: Everyone gets the same versions of tools and compilers
 - **Matches CI**: The Linux CI runs in Docker images built from this exact Nix environment, and CI builds some macOS configurations in it as well
 - **No system pollution**: Dependencies are isolated and don't affect your system packages
+- **Consistent compilers**: The GCC and Clang shells use the same versions as CI
 - **Quick setup**: Get started with a single command
+- **Works on Linux and macOS**: Consistent experience across platforms
 
 ## Install Nix
 
@@ -25,8 +27,13 @@ From the root of the xrpld repository, enter the default development shell:
 nix --experimental-features 'nix-command flakes' develop
 ```
 
-This downloads and sets up all required development tools (CMake, Ninja, Conan, etc.)
-and the compiler for your platform (see [Platform notes](#platform-notes)).
+This will:
+
+- Download and set up all required development tools (CMake, Ninja, Conan, etc.)
+- Configure the appropriate compiler for your platform:
+  - **Linux**: GCC (provided by Nix)
+  - **macOS**: Clang (provided by Nix)
+
 The first time you run this command, it will take a few minutes to download and build the environment. Subsequent runs will be much faster.
 
 ### Platform notes

docs/install.md

@@ -10,19 +10,6 @@ and DNF on Red Hat-based distributions such as RHEL, AlmaLinux, and Rocky Linux,
 where `yum` is a symlink to `dnf`.
 To build from source instead, see [BUILD.md](../BUILD.md).
 
-## Requirements
-
-Linux is the only operating system officially supported for running `xrpld`;
-macOS and Windows builds are for development only.
-
-Any x86-64 Linux distribution with APT or DNF and glibc 2.31 or newer should work
-(see [How libc is handled](../nix/docker/README.md#how-libc-is-handled)).
-CI tests the packages on Debian 11–13, Ubuntu 20.04–26.04,
-RHEL (UBI) 9–10, AlmaLinux 9–10, and Rocky Linux 9–10.
-
-For the hardware needed to run a node,
-see [System Requirements](https://xrpl.org/system-requirements.html).
-
 ## Release channels
 
 Packages are published to four channels:

include/xrpl/basics/MathUtilities.h

@@ -39,31 +39,6 @@ checkedSub(std::int64_t a, std::int64_t b) noexcept
     return a - b;
 }
 
-/**
- * Multiply two signed 64-bit integers, returning std::nullopt when the exact
- * mathematical product is not representable in std::int64_t.
- */
-[[nodiscard]] constexpr std::optional<std::int64_t>
-checkedMul(std::int64_t a, std::int64_t b) noexcept
-{
-    using L = std::numeric_limits<std::int64_t>;
-
-    if (a == 0 || b == 0)
-        return 0;
-
-    if (a > 0)
-    {
-        if (b > 0 ? a > L::max() / b : b < L::min() / a)
-            return std::nullopt;
-    }
-    else if (b > 0 ? a < L::min() / b : b < L::max() / a)
-    {
-        return std::nullopt;
-    }
-
-    return a * b;
-}
-
 static_assert(checkedAdd(0, 0) == 0);
 static_assert(checkedAdd(1, -1) == 0);
 static_assert(checkedAdd(-5, 2) == -3);
@@ -106,53 +81,6 @@ static_assert(
     !checkedSub(std::numeric_limits<std::int64_t>::min(), std::numeric_limits<std::int64_t>::max())
          .has_value());
 
-static_assert(checkedMul(0, std::numeric_limits<std::int64_t>::min()) == 0);
-static_assert(checkedMul(std::numeric_limits<std::int64_t>::min(), 0) == 0);
-static_assert(checkedMul(-1, -1) == 1);
-// a > 0, b > 0
-static_assert(
-    checkedMul(std::numeric_limits<std::int64_t>::max(), 1) ==
-    std::numeric_limits<std::int64_t>::max());
-static_assert(
-    checkedMul(std::numeric_limits<std::int64_t>::max() / 2, 2) ==
-    std::numeric_limits<std::int64_t>::max() - 1);
-static_assert(!checkedMul((std::numeric_limits<std::int64_t>::max() / 2) + 1, 2).has_value());
-static_assert(!checkedMul(2, (std::numeric_limits<std::int64_t>::max() / 2) + 1).has_value());
-// a > 0, b < 0
-static_assert(
-    checkedMul(std::numeric_limits<std::int64_t>::max(), -1) ==
-    -std::numeric_limits<std::int64_t>::max());
-static_assert(
-    checkedMul((std::numeric_limits<std::int64_t>::max() / 2) + 1, -2) ==
-    std::numeric_limits<std::int64_t>::min());
-static_assert(!checkedMul((std::numeric_limits<std::int64_t>::max() / 2) + 2, -2).has_value());
-static_assert(
-    checkedMul(1, std::numeric_limits<std::int64_t>::min()) ==
-    std::numeric_limits<std::int64_t>::min());
-static_assert(
-    checkedMul(2, std::numeric_limits<std::int64_t>::min() / 2) ==
-    std::numeric_limits<std::int64_t>::min());
-static_assert(!checkedMul(2, (std::numeric_limits<std::int64_t>::min() / 2) - 1).has_value());
-// a < 0, b > 0
-static_assert(
-    checkedMul(std::numeric_limits<std::int64_t>::min(), 1) ==
-    std::numeric_limits<std::int64_t>::min());
-static_assert(
-    checkedMul(std::numeric_limits<std::int64_t>::min() / 2, 2) ==
-    std::numeric_limits<std::int64_t>::min());
-static_assert(!checkedMul((std::numeric_limits<std::int64_t>::min() / 2) - 1, 2).has_value());
-static_assert(!checkedMul(std::numeric_limits<std::int64_t>::min(), 2).has_value());
-// a < 0, b < 0
-static_assert(
-    checkedMul(-(std::numeric_limits<std::int64_t>::max() / 2), -2) ==
-    std::numeric_limits<std::int64_t>::max() - 1);
-static_assert(!checkedMul(std::numeric_limits<std::int64_t>::min() / 2, -2).has_value());
-static_assert(
-    checkedMul(-1, -std::numeric_limits<std::int64_t>::max()) ==
-    std::numeric_limits<std::int64_t>::max());
-static_assert(!checkedMul(std::numeric_limits<std::int64_t>::min(), -1).has_value());
-static_assert(!checkedMul(-1, std::numeric_limits<std::int64_t>::min()).has_value());
-
 /**
  * Calculate one number divided by another number in percentage.
  * The result is rounded up to the next integer, and capped in the range [0,100]

include/xrpl/basics/Number.h

@@ -352,9 +352,9 @@ class Number final
     using rep = std::int64_t;
     using InternalRep = MantissaRange::rep;
 
+    bool negative_{false};
     InternalRep mantissa_{0};
     int exponent_{std::numeric_limits<int>::lowest()};
-    bool negative_{false};
 
 public:
     // The range for the exponent when normalized
@@ -650,12 +650,8 @@ private:
     shiftExponent(int exponentDelta) const;
 };
 
-// The number class currently has 3 tail padding bytes. If you are adding new
-// members, try to fit them there before expanding the size of the class.
-static_assert(sizeof(Number) == 16);
-
 constexpr Number::Number(bool negative, InternalRep mantissa, int exponent, Unchecked) noexcept
-    : mantissa_{mantissa}, exponent_{exponent}, negative_(negative)
+    : negative_(negative), mantissa_{mantissa}, exponent_{exponent}
 {
 }
 

include/xrpl/basics/TaggedCache.h

@@ -153,24 +153,6 @@ private:
         Policy policy,
         Callback&& replaceCallback = nullptr);
 
-    /**
-     * canonicalizeImpl variant for callers that already hold `mutex_`.
-     *
-     * The unnamed `scoped_lock<MutexType> const&` parameter is proof of
-     * ownership; this overload does not acquire the lock. Use it from other
-     * methods (e.g. fetchAndModify) that need to compose canonicalize with
-     * additional work under a single critical section, without relying on
-     * recursive-mutex re-entry.
-     */
-    template <class Policy, class Callback = std::nullptr_t>
-    bool
-    canonicalizeImpl(
-        std::scoped_lock<MutexType> const&,
-        key_type const& key,
-        CanonicalizeClientPointerType<Policy> data,
-        Policy policy,
-        Callback&& replaceCallback = nullptr);
-
 public:
     /**
      * Replace aliased objects with originals.
@@ -257,6 +239,9 @@ public:
     bool
     retrieve(key_type const& key, T& data);
 
+    MutexType&
+    peekMutex();
+
     std::vector<key_type>
     getKeys() const;
 
@@ -278,22 +263,6 @@ public:
     fetch(key_type const& digest, Handler const& h);
     // End CachedSLEs functions.
 
-    /**
-     * Fetch or create an entry and execute a callback while holding the lock.
-     *
-     * The entry for the given key is fetched from the cache or created if it
-     * doesn't exist. The callback is then invoked with a reference to the
-     * entry while the cache mutex is still held, allowing safe modification
-     * of the cached object.
-     *
-     * @param key The key to fetch or create
-     * @param callback Function to call with the entry under lock.
-     *                 Signature: void(T&)
-     */
-    template <class Callback>
-    void
-    fetchAndModify(key_type const& key, Callback&& callback);
-
 private:
     SharedPointerType
     initialFetch(key_type const& key, std::scoped_lock<MutexType> const& l);

include/xrpl/basics/TaggedCache.ipp

@@ -4,7 +4,6 @@
 #include <xrpl/basics/Log.h>  // IWYU pragma: keep
 #include <xrpl/basics/TaggedCache.h>
 #include <xrpl/basics/scope.h>
-#include <xrpl/beast/utility/instrumentation.h>
 
 #include <algorithm>
 
@@ -336,29 +335,6 @@ template <class Policy, class Callback>
 inline bool
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     canonicalizeImpl(
-        key_type const& key,
-        CanonicalizeClientPointerType<Policy> data,
-        Policy policy,
-        Callback&& replaceCallback)
-{
-    std::scoped_lock<MutexType> const lock(mutex_);
-    return canonicalizeImpl(lock, key, data, policy, std::forward<Callback>(replaceCallback));
-}
-
-template <
-    class Key,
-    class T,
-    bool IsKeyCache,
-    class SharedWeakUnionPointer,
-    class SharedPointerType,
-    class Hash,
-    class KeyEqual,
-    class Mutex>
-template <class Policy, class Callback>
-inline bool
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    canonicalizeImpl(
-        std::scoped_lock<MutexType> const&,
         key_type const& key,
         CanonicalizeClientPointerType<Policy> data,
         [[maybe_unused]] Policy policy,
@@ -378,6 +354,8 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     // passing a const argument is a compile error.
     constexpr bool replaceCached = std::is_same_v<Policy, detail::ReplaceCached>;
 
+    std::scoped_lock const lock(mutex_);
+
     auto const cit = cache_.find(key);
 
     if (cit == cache_.end())
@@ -594,6 +572,22 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     return true;
 }
 
+template <
+    class Key,
+    class T,
+    bool IsKeyCache,
+    class SharedWeakUnionPointer,
+    class SharedPointerType,
+    class Hash,
+    class KeyEqual,
+    class Mutex>
+inline auto
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    peekMutex() -> MutexType&
+{
+    return mutex_;
+}
+
 template <
     class Key,
     class T,
@@ -706,49 +700,6 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 }
 // End CachedSLEs functions.
 
-template <
-    class Key,
-    class T,
-    bool IsKeyCache,
-    class SharedWeakUnionPointer,
-    class SharedPointerType,
-    class Hash,
-    class KeyEqual,
-    class Mutex>
-template <class Callback>
-inline void
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    fetchAndModify(key_type const& key, Callback&& callback)
-{
-    static_assert(
-        !IsKeyCache, "fetchAndModify is only supported for value caches, not key-only caches");
-    static_assert(
-        std::is_same_v<std::shared_ptr<T>, SharedPointerType> ||
-            std::is_same_v<intr_ptr::SharedPtr<T>, SharedPointerType>,
-        "fetchAndModify requires std::shared_ptr<T> or intr_ptr::SharedPtr<T>");
-
-    std::scoped_lock<MutexType> const lock(mutex_);
-
-    // Same pointer-type dispatch as insert(): the placeholder must have exactly
-    // SharedPointerType so canonicalizeImpl can write the cached pointer back.
-    SharedPointerType entry = [] {
-        if constexpr (std::is_same_v<std::shared_ptr<T>, SharedPointerType>)
-        {
-            return std::make_shared<T>();
-        }
-        else
-        {
-            return intr_ptr::makeShared<T>();
-        }
-    }();
-    canonicalizeImpl(lock, key, entry, detail::ReplaceClient{});
-
-    ALWAYS(
-        entry != nullptr, "xrpl::TaggedCache::fetchAndModify : entry present after canonicalize");
-
-    callback(*entry);
-}
-
 template <
     class Key,
     class T,

include/xrpl/config/Constants.h

@@ -94,7 +94,6 @@ struct Keys
     static constexpr auto kBbtOptions = "bbt_options";
     static constexpr auto kBgThreads = "bg_threads";
     static constexpr auto kBlockSize = "block_size";
-    static constexpr auto kBytecodeSizeLimit = "bytecode_size_limit";
     static constexpr auto kCacheAge = "cache_age";
     static constexpr auto kCacheMb = "cache_mb";
     static constexpr auto kCacheSize = "cache_size";
@@ -109,8 +108,6 @@ struct Keys
     static constexpr auto kFileSizeMult = "file_size_mult";
     static constexpr auto kFilterBits = "filter_bits";
     static constexpr auto kFilterFull = "filter_full";
-    static constexpr auto kGasLimit = "gas_limit";
-    static constexpr auto kGasPrice = "gas_price";
     static constexpr auto kHardSet = "hard_set";
     static constexpr auto kHighThreads = "high_threads";
     static constexpr auto kHoldTime = "hold_time";

include/xrpl/json/json_value.h

@@ -3,11 +3,13 @@
 #include <xrpl/basics/Number.h>
 #include <xrpl/json/json_forwards.h>
 
+#include <concepts>
 #include <cstring>
 #include <iterator>
 #include <limits>
 #include <map>
 #include <string>
+#include <string_view>
 #include <vector>
 
 /**
@@ -198,6 +200,15 @@ public:
      */
     Value(StaticString const& value);
     Value(std::string const& value);
+    /**
+     * @brief Constructs a value from a string view.
+     *
+     * The characters are copied, so the view need not outlive the call and need
+     * not be NUL-terminated.
+     *
+     * @param value The characters to copy.
+     */
+    Value(std::string_view value);
     Value(bool value);
     Value(Value const& other);
     ~Value();
@@ -472,6 +483,32 @@ toJson(xrpl::Number const& number)
 bool
 operator==(Value const&, Value const&);
 
+/**
+ * Compares a value with a string view, reading the value's characters in place
+ * rather than building a Value from the view.
+ *
+ * Constrained to the exact type: a string literal converts equally well to a
+ * view and to a Value, so a plain overload makes `value == "literal"`
+ * ambiguous.
+ *
+ * @param x The value to compare.
+ * @param y The characters to compare it against.
+ * @return Whether `x` is a string whose characters up to its first NUL are
+ *         exactly the characters of `y`.
+ */
+template <class T>
+    requires std::same_as<T, std::string_view>
+bool
+operator==(Value const& x, T y)
+{
+    if (!x.isString())
+        return false;
+
+    // A string `Value` can hold a null pointer, which names no characters, so it equals no view.
+    char const* const s = x.asCString();
+    return s != nullptr && std::string_view{s} == y;
+}
+
 bool
 operator<(Value const&, Value const&);
 

include/xrpl/ledger/Ledger.h

@@ -257,42 +257,13 @@ public:
         header_.validated = true;
     }
 
-    /**
-     * Mark this ledger as accepted and attempt to make it immutable.
-     *
-     * The close-time fields are recorded first, since the ledger hash covers
-     * them.
-     *
-     * @param closeTime The consensus-agreed close time.
-     * @param closeResolution The close time resolution.
-     * @param correctCloseTime Whether consensus agreed on the close time. If
-     *        false, kSLcfNoConsensusTime is recorded in closeFlags instead.
-     * @return What setImmutable() returned.
-     */
-    [[nodiscard]] bool
+    void
     setAccepted(
         NetClock::time_point closeTime,
         NetClock::duration closeResolution,
         bool correctCloseTime);
 
-    /**
-     * Mark this ledger as immutable, so it can no longer be modified.
-     *
-     * A ledger built or loaded locally cannot have an invalid map, since only
-     * a map syncing against hashes from outside can be proven impossible (see
-     * SHAMap::addKnownNode), so a caller on such a path may treat a false
-     * return as a broken internal invariant. A caller assembling a ledger from
-     * peer data may not: for it, false is an outcome a peer can produce.
-     *
-     * @param rehash Whether to recompute the ledger hash from the header
-     *        fields. The transaction and account hashes are recomputed from the
-     *        maps too, but only the first time.
-     * @return false if either map is Invalid, leaving the immutable flag as it
-     *         was and the header untouched. A map invalidated partway through can
-     *         still leave the other one immutable, so a false return means the
-     *         ledger must be discarded rather than retried.
-     */
-    [[nodiscard]] bool
+    void
     setImmutable(bool rehash = true);
 
     bool
@@ -301,28 +272,23 @@ public:
         return immutable_;
     }
 
-    /**
-     * @return Whether both maps can still be the maps the header names. See
-     *         SHAMap::isValid().
-     */
-    [[nodiscard]] bool
-    mapsValid() const
-    {
-        return txMap_.isValid() && stateMap_.isValid();
-    }
+    /*  Mark this ledger as "should be full".
 
-    /**
-     * Mark this ledger as "should be full", indicating that the local server
-     * wants all the corresponding nodes in durable storage.
-     *
-     * Const because it reflects metadata, not data this ledger shares with
-     * other nodes on the network.
-     */
+        "Full" is metadata property of the ledger, it indicates
+        that the local server wants all the corresponding nodes
+        in durable storage.
+
+        This is marked `const` because it reflects metadata
+        and not data that is in common with other nodes on the
+        network.
+    */
     void
     setFull() const
     {
-        txMap_.setFull(header_.seq);
-        stateMap_.setFull(header_.seq);
+        txMap_.setFull();
+        txMap_.setLedgerSeq(header_.seq);
+        stateMap_.setFull();
+        stateMap_.setLedgerSeq(header_.seq);
     }
 
     void
@@ -452,22 +418,6 @@ private:
     static std::pair<std::shared_ptr<STTx const>, std::shared_ptr<STObject const>>
     deserializeTxPlusMeta(SHAMapItem const& item);
 
-    /**
-     * Make both maps immutable.
-     *
-     * Each map is settled on its own, so neither is left mid-sync because the
-     * other refused.
-     *
-     * @return Whether both maps are immutable.
-     */
-    [[nodiscard]] bool
-    setMapsImmutable()
-    {
-        bool const txImmutable = txMap_.setImmutable();
-        bool const stateImmutable = stateMap_.setImmutable();
-        return txImmutable && stateImmutable;
-    }
-
     bool immutable_;
 
     // A SHAMap containing the transactions associated with this ledger.

include/xrpl/ledger/View.h

@@ -265,13 +265,6 @@ canWithdraw(
 [[nodiscard]] TER
 canWithdraw(ReadView const& view, STTx const& tx);
 
-/**
- * Pays out a withdrawal from a vault or loan broker pseudo-account.
- *
- * `sourceAmount` leaves `sourceAcct` and `destinationAmount` reaches `dstAcct`.
- * The two differ only when the withdrawal carries a transfer fee; the
- * difference is the fee and is settled through the issuer.
- */
 [[nodiscard]] TER
 doWithdraw(
     ApplyViewContext ctx,
@@ -279,8 +272,7 @@ doWithdraw(
     AccountID const& dstAcct,
     AccountID const& sourceAcct,
     XRPAmount priorBalance,
-    STAmount const& destinationAmount,
-    STAmount const& sourceAmount,
+    STAmount const& amount,
     beast::Journal j);
 
 /**

include/xrpl/ledger/entries/BridgeEntry.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STXChainBridge.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class BridgeEntry : public SLEBase<ViewT, ltBRIDGE>
+{
+public:
+    using Base = SLEBase<ViewT, ltBRIDGE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit BridgeEntry(
+        STXChainBridge const& bridge,
+        STXChainBridge::ChainType chainType,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::bridge(bridge, chainType), view, j)
+    {
+    }
+};
+
+using BridgeEntryR = BridgeEntry<ReadView>;
+using BridgeEntryW = BridgeEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/entries/XChainOwnedClaimIDEntry.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STXChainBridge.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+template <typename ViewT>
+class XChainOwnedClaimIDEntry : public SLEBase<ViewT, ltXCHAIN_OWNED_CLAIM_ID>
+{
+public:
+    using Base = SLEBase<ViewT, ltXCHAIN_OWNED_CLAIM_ID>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit XChainOwnedClaimIDEntry(
+        STXChainBridge const& bridge,
+        std::uint64_t seq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::xChainClaimID(bridge, seq), view, j)
+    {
+    }
+};
+
+using XChainOwnedClaimIDEntryR = XChainOwnedClaimIDEntry<ReadView>;
+using XChainOwnedClaimIDEntryW = XChainOwnedClaimIDEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/entries/XChainOwnedCreateAccountClaimIDEntry.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STXChainBridge.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+template <typename ViewT>
+class XChainOwnedCreateAccountClaimIDEntry
+    : public SLEBase<ViewT, ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID>
+{
+public:
+    using Base = SLEBase<ViewT, ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit XChainOwnedCreateAccountClaimIDEntry(
+        STXChainBridge const& bridge,
+        std::uint64_t seq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::xChainCreateAccountClaimID(bridge, seq), view, j)
+    {
+    }
+};
+
+using XChainOwnedCreateAccountClaimIDEntryR = XChainOwnedCreateAccountClaimIDEntry<ReadView>;
+using XChainOwnedCreateAccountClaimIDEntryW = XChainOwnedCreateAccountClaimIDEntry<ApplyView>;
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/AMMHelpers.h

@@ -2,6 +2,7 @@
 
 #include <xrpl/basics/Log.h>
 #include <xrpl/basics/Number.h>
+#include <xrpl/basics/contract.h>
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/beast/utility/Zero.h>
 #include <xrpl/ledger/ApplyView.h>
@@ -28,6 +29,7 @@
 #include <expected>
 #include <functional>
 #include <optional>
+#include <stdexcept>
 #include <tuple>
 #include <utility>
 
@@ -311,11 +313,11 @@ getAMMOfferStartWithTakerPays(
  * is equal to LOB quality (in this case AMM offer quality is
  * better than LOB quality) or AMM offer is equal to LOB quality
  * (in this case SPQ is better than LOB quality).
- * The economically coarser integral offer side is calculated first. The
- * result is rounded down, which makes the offer quality better. Calculating
- * takerPays first instead would round down takerGets when that is the coarser
- * side, giving worse quality than LOB quality, and the offer might fail to
- * generate.
+ * Pre-amendment code calculates takerPays first. If takerGets is the
+ * economically coarser integral side, it is rounded down, which results in
+ * worse offer quality than LOB quality, and the offer might fail to generate.
+ * Post-amendment code calculates the economically coarser integral offer side
+ * first. The result is rounded down, which makes the offer quality better.
  *   It might not be possible to match either SPQ or AMM offer to LOB
  * quality. This generally happens at higher fees.
  * @param pool AMM pool balances
@@ -329,8 +331,69 @@ changeSpotPriceQuality(
     TAmounts<TIn, TOut> const& pool,
     Quality const& quality,
     std::uint16_t tfee,
+    Rules const& rules,
     beast::Journal j)
 {
+    if (!rules.enabled(fixAMMv1_1))
+    {
+        // Finds takerPays (i) and takerGets (o) such that given pool
+        // composition poolGets(I) and poolPays(O): (O - o) / (I + i) = quality.
+        // Where takerGets is calculated as the swapAssetIn (see below).
+        // The above equation produces the quadratic equation:
+        // i^2*(1-fee) + i*I*(2-fee) + I^2 - I*O/quality,
+        // which is solved for i, and o is found with swapAssetIn().
+        auto const f = feeMult(tfee);  // 1 - fee
+        auto const& a = f;
+        auto const b = pool.in * (1 + f);
+        Number const c = pool.in * pool.in - pool.in * pool.out * quality.rate();
+        auto const res = b * b - 4 * a * c;
+        if (res < 0)
+        {
+            return std::nullopt;  // LCOV_EXCL_LINE
+        }
+        if (auto const nTakerPaysPropose = (-b + root2(res)) / (2 * a); nTakerPaysPropose > 0)
+        {
+            auto const nTakerPays = [&] {
+                // The fee might make the AMM offer quality less than CLOB
+                // quality. Therefore, AMM offer has to satisfy this constraint:
+                // o / i >= q. Substituting o with swapAssetIn() gives: i <= O /
+                // q - I / (1 - fee).
+                auto const nTakerPaysConstraint = pool.out * quality.rate() - pool.in / f;
+                if (nTakerPaysPropose > nTakerPaysConstraint)
+                    return nTakerPaysConstraint;
+                return nTakerPaysPropose;
+            }();
+            if (nTakerPays <= 0)
+            {
+                JLOG(j.trace()) << "changeSpotPriceQuality calc failed: " << to_string(pool.in)
+                                << " " << to_string(pool.out) << " " << quality << " " << tfee;
+                return std::nullopt;
+            }
+            auto const takerPays =
+                toAmount<TIn>(getAsset(pool.in), nTakerPays, Number::RoundingMode::Upward);
+            // should not fail
+            auto amounts = TAmounts<TIn, TOut>{takerPays, swapAssetIn(pool, takerPays, tfee)};
+            if (Quality{amounts} < quality &&
+                !withinRelativeDistance(Quality{amounts}, quality, Number(1, -7)))
+            {
+                JLOG(j.error()) << "changeSpotPriceQuality failed: " << to_string(pool.in) << " "
+                                << to_string(pool.out) << " "
+                                << " " << quality << " " << tfee << " " << to_string(amounts.in)
+                                << " " << to_string(amounts.out);
+                Throw<std::runtime_error>("changeSpotPriceQuality failed");
+            }
+
+            JLOG(j.trace()) << "changeSpotPriceQuality succeeded: " << to_string(pool.in) << " "
+                            << to_string(pool.out) << " "
+                            << " " << quality << " " << tfee << " " << to_string(amounts.in) << " "
+                            << to_string(amounts.out);
+            return amounts;
+        }
+        JLOG(j.trace()) << "changeSpotPriceQuality calc failed: " << to_string(pool.in) << " "
+                        << to_string(pool.out) << " " << quality << " " << tfee;
+        return std::nullopt;
+    }
+
     auto amounts = [&] {
         bool const inIntegral = getAsset(pool.in).integral();
         bool const outIntegral = getAsset(pool.out).integral();
@@ -396,49 +459,57 @@ template <typename TIn, typename TOut>
 TOut
 swapAssetIn(TAmounts<TIn, TOut> const& pool, TIn const& assetIn, std::uint16_t tfee)
 {
-    // set rounding to always favor the amm. Clip to zero.
-    // calculate:
-    // pool.out -
-    // (pool.in * pool.out) / (pool.in + assetIn * feeMult(tfee)),
-    // and explicitly set the rounding modes
-    // Favoring the amm means we should:
-    // minimize:
-    // pool.out -
-    // (pool.in * pool.out) / (pool.in + assetIn * feeMult(tfee)),
-    // maximize:
-    // (pool.in * pool.out) / (pool.in + assetIn * feeMult(tfee)),
-    // (pool.in * pool.out)
-    // minimize:
-    // (pool.in + assetIn * feeMult(tfee)),
-    // minimize:
-    // assetIn * feeMult(tfee)
-    // feeMult is: (1-fee), fee is tfee/100000
-    // minimize:
-    // 1-fee
-    // maximize:
-    // fee
-    SaveNumberRoundMode const _{Number::getround()};
+    if (auto const& rules = getCurrentTransactionRules(); rules && rules->enabled(fixAMMv1_1))
+    {
+        // set rounding to always favor the amm. Clip to zero.
+        // calculate:
+        // pool.out -
+        // (pool.in * pool.out) / (pool.in + assetIn * feeMult(tfee)),
+        // and explicitly set the rounding modes
+        // Favoring the amm means we should:
+        // minimize:
+        // pool.out -
+        // (pool.in * pool.out) / (pool.in + assetIn * feeMult(tfee)),
+        // maximize:
+        // (pool.in * pool.out) / (pool.in + assetIn * feeMult(tfee)),
+        // (pool.in * pool.out)
+        // minimize:
+        // (pool.in + assetIn * feeMult(tfee)),
+        // minimize:
+        // assetIn * feeMult(tfee)
+        // feeMult is: (1-fee), fee is tfee/100000
+        // minimize:
+        // 1-fee
+        // maximize:
+        // fee
+        SaveNumberRoundMode const _{Number::getround()};
 
-    Number::setround(Number::RoundingMode::Upward);
-    auto const numerator = pool.in * pool.out;
-    auto const fee = getFee(tfee);
+        Number::setround(Number::RoundingMode::Upward);
+        auto const numerator = pool.in * pool.out;
+        auto const fee = getFee(tfee);
 
-    Number::setround(Number::RoundingMode::Downward);
-    auto const denom = pool.in + assetIn * (1 - fee);
+        Number::setround(Number::RoundingMode::Downward);
+        auto const denom = pool.in + assetIn * (1 - fee);
 
-    if (denom.signum() <= 0)
-        return toAmount<TOut>(getAsset(pool.out), 0);
+        if (denom.signum() <= 0)
+            return toAmount<TOut>(getAsset(pool.out), 0);
 
-    Number::setround(Number::RoundingMode::Upward);
-    auto const ratio = numerator / denom;
+        Number::setround(Number::RoundingMode::Upward);
+        auto const ratio = numerator / denom;
 
-    Number::setround(Number::RoundingMode::Downward);
-    auto const swapOut = pool.out - ratio;
+        Number::setround(Number::RoundingMode::Downward);
+        auto const swapOut = pool.out - ratio;
 
-    if (swapOut.signum() < 0)
-        return toAmount<TOut>(getAsset(pool.out), 0);
+        if (swapOut.signum() < 0)
+            return toAmount<TOut>(getAsset(pool.out), 0);
 
-    return toAmount<TOut>(getAsset(pool.out), swapOut, Number::RoundingMode::Downward);
+        return toAmount<TOut>(getAsset(pool.out), swapOut, Number::RoundingMode::Downward);
+    }
+
+    return toAmount<TOut>(
+        getAsset(pool.out),
+        pool.out - (pool.in * pool.out) / (pool.in + assetIn * feeMult(tfee)),
+        Number::RoundingMode::Downward);
 }
 
 /**
@@ -455,49 +526,57 @@ template <typename TIn, typename TOut>
 TIn
 swapAssetOut(TAmounts<TIn, TOut> const& pool, TOut const& assetOut, std::uint16_t tfee)
 {
-    // set rounding to always favor the amm. Clip to zero.
-    // calculate:
-    // ((pool.in * pool.out) / (pool.out - assetOut) - pool.in) /
-    // (1-tfee/100000)
-    // maximize:
-    // ((pool.in * pool.out) / (pool.out - assetOut) - pool.in)
-    // maximize:
-    // (pool.in * pool.out) / (pool.out - assetOut)
-    // maximize:
-    // (pool.in * pool.out)
-    // minimize
-    // (pool.out - assetOut)
-    // minimize:
-    // (1-tfee/100000)
-    // maximize:
-    // tfee/100000
-
-    SaveNumberRoundMode const _{Number::getround()};
-
-    Number::setround(Number::RoundingMode::Upward);
-    auto const numerator = pool.in * pool.out;
-
-    Number::setround(Number::RoundingMode::Downward);
-    auto const denom = pool.out - assetOut;
-    if (denom.signum() <= 0)
+    if (auto const& rules = getCurrentTransactionRules(); rules && rules->enabled(fixAMMv1_1))
     {
-        return toMaxAmount<TIn>(getAsset(pool.in));
+        // set rounding to always favor the amm. Clip to zero.
+        // calculate:
+        // ((pool.in * pool.out) / (pool.out - assetOut) - pool.in) /
+        // (1-tfee/100000)
+        // maximize:
+        // ((pool.in * pool.out) / (pool.out - assetOut) - pool.in)
+        // maximize:
+        // (pool.in * pool.out) / (pool.out - assetOut)
+        // maximize:
+        // (pool.in * pool.out)
+        // minimize
+        // (pool.out - assetOut)
+        // minimize:
+        // (1-tfee/100000)
+        // maximize:
+        // tfee/100000
+
+        SaveNumberRoundMode const _{Number::getround()};
+
+        Number::setround(Number::RoundingMode::Upward);
+        auto const numerator = pool.in * pool.out;
+
+        Number::setround(Number::RoundingMode::Downward);
+        auto const denom = pool.out - assetOut;
+        if (denom.signum() <= 0)
+        {
+            return toMaxAmount<TIn>(getAsset(pool.in));
+        }
+
+        Number::setround(Number::RoundingMode::Upward);
+        auto const ratio = numerator / denom;
+        auto const numerator2 = ratio - pool.in;
+        auto const fee = getFee(tfee);
+
+        Number::setround(Number::RoundingMode::Downward);
+        auto const feeMult = 1 - fee;
+
+        Number::setround(Number::RoundingMode::Upward);
+        auto const swapIn = numerator2 / feeMult;
+        if (swapIn.signum() < 0)
+            return toAmount<TIn>(getAsset(pool.in), 0);
+
+        return toAmount<TIn>(getAsset(pool.in), swapIn, Number::RoundingMode::Upward);
     }
 
-    Number::setround(Number::RoundingMode::Upward);
-    auto const ratio = numerator / denom;
-    auto const numerator2 = ratio - pool.in;
-    auto const fee = getFee(tfee);
-
-    Number::setround(Number::RoundingMode::Downward);
-    auto const feeMult = 1 - fee;
-
-    Number::setround(Number::RoundingMode::Upward);
-    auto const swapIn = numerator2 / feeMult;
-    if (swapIn.signum() < 0)
-        return toAmount<TIn>(getAsset(pool.in), 0);
-
-    return toAmount<TIn>(getAsset(pool.in), swapIn, Number::RoundingMode::Upward);
+    return toAmount<TIn>(
+        getAsset(pool.in),
+        ((pool.in * pool.out) / (pool.out - assetOut) - pool.in) / feeMult(tfee),
+        Number::RoundingMode::Upward);
 }
 
 /**

include/xrpl/ledger/helpers/EscrowHelpers.h

@@ -14,7 +14,6 @@
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Concepts.h>
 #include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Fees.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/Keylet.h>
@@ -28,8 +27,6 @@
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/UintTypes.h>
 
-#include <cstdint>
-
 namespace xrpl {
 
 /**
@@ -563,54 +560,4 @@ escrowUnlockApplyHelper<MPTIssue>(
         journal);
 }
 
-/**
- * Smart escrow kill switches, driven by the voted FeeSettings.
- *
- * Zeroing `bytecodeSizeLimit` stops new uploads while leaving existing escrows
- * finishable without forcing holders to wait for `CancelAfter`.
- * Zeroing `gasLimit` stops both.
- */
-/** @{ */
-inline bool
-isBytecodeUploadDisabled(Fees const& fees)
-{
-    return fees.bytecodeSizeLimit == 0 || fees.gasLimit == 0;
-}
-
-inline bool
-isBytecodeExecutionDisabled(Fees const& fees)
-{
-    return fees.gasLimit == 0;
-}
-/** @} */
-
-/**
- * Owner count an escrow costs.
- *
- *  An escrow costs one increment per started 500 bytes of bytecode, and one
- *  increment if it carries no bytecode.
- */
-template <class T>
-int32_t
-calculateAdditionalReserve(T const& finishFunction)
-{
-    static auto constexpr kBytecodeReserveIncrement = 500;
-
-    if (!finishFunction)
-        return 1;
-
-    auto const size = finishFunction->size();
-    if (size == 0)
-    {
-        // LCOV_EXCL_START
-        // Empty Bytecode is refused at create, so no escrow carries it. Ceiling
-        // division would answer 0, which would subtract less than the create added.
-        UNREACHABLE("xrpl::calculateAdditionalReserve : empty Bytecode");
-        return 1;
-        // LCOV_EXCL_STOP
-    }
-
-    return static_cast<int32_t>((size + kBytecodeReserveIncrement - 1) / kBytecodeReserveIncrement);
-}
-
 }  // namespace xrpl

include/xrpl/ledger/helpers/LendingHelpers.h

@@ -7,10 +7,10 @@
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/ledger/ApplyView.h>
 #include <xrpl/ledger/ReadView.h>
-#include <xrpl/ledger/helpers/VaultHelpers.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Asset.h>
 #include <xrpl/protocol/LedgerFormats.h>  // IWYU pragma: keep
+#include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STAmount.h>
@@ -31,9 +31,9 @@ namespace xrpl {
 /**
  * Broker cover preclaim precision guard (fixCleanup3_2_0).
  *
- * Prevents a silent sub-ULP no-op where a deposit, withdrawal, or clawback
- * amount is so small that it rounds to zero at sfCoverAvailable's scale.
- * Without this guard, both the pseudo trust-line and sfCoverAvailable would
+ * Prevents a "silent sub-ULP no-op" where a deposit, withdrawal, or clawback
+ * amount is so small that it rounds to zero at `sfCoverAvailable`'s scale.
+ * Without this guard, both the pseudo trust-line and `sfCoverAvailable` would
  * identically absorb the rounded zero, resulting in a successful transaction
  * (tesSUCCESS) where no funds actually moved.
  *
@@ -44,8 +44,8 @@ namespace xrpl {
  * @param j          Journal for logging.
  * @param logPrefix  Transactor name for log diagnostics.
  *
- * @return tecPRECISION_LOSS if the request rounds to zero at cover scale.
- * tesSUCCESS if the amendment is disabled or the request is safely supra-ULP.
+ * @return `tecPRECISION_LOSS` if the request rounds to zero at cover scale.
+ * `tesSUCCESS` if the amendment is disabled or the request is safely supra-ULP.
  */
 [[nodiscard]] TER
 canApplyToBrokerCover(
@@ -56,82 +56,6 @@ canApplyToBrokerCover(
     beast::Journal j,
     std::string_view logPrefix);
 
-namespace detail {
-
-/**
- * Return a LoanBroker's posterior live cover exponent after applying an
- * unrounded delta.
- */
-[[nodiscard]] int
-getPosteriorBrokerCoverScale(SLE::ConstRef vault, SLE::ConstRef broker, Number const& delta);
-
-/**
- * Round a cover outflow delta (cover withdraw, cover clawback, the
- * broker-side decrease of a default's cover credit) at the LoanBroker's
- * posterior live exponent. Safe to round the delta directly for an outflow:
- * amount on the posterior grid of CoverAvailable always leaves CoverAvailable
- * minus amount representable, since the posterior grid is exactly the grid
- * CoverAvailable itself will canonicalize to after the subtraction.
- */
-[[nodiscard]] STAmount
-roundToPosteriorBrokerCoverScale(
-    SLE::ConstRef vault,
-    SLE::ConstRef broker,
-    STAmount const& delta,
-    Number::RoundingMode roundingMode);
-
-}  // namespace detail
-
-/**
- * Round a cover debit (cover withdraw, cover clawback, the broker-side
- * decrease of a default's cover credit): amount is the non-negative
- * magnitude leaving CoverAvailable. Negates so the posterior is computed for
- * CoverAvailable minus amount, then negates the result back to a
- * non-negative magnitude, per roundToPosteriorBrokerCoverScale's outflow
- * rationale above. Magnitude in, magnitude out -- unlike the vault-side
- * outflow dispatcher (clampVaultOutflow), which takes and returns a negative
- * delta; callers on each side already hold the value in that side's native
- * form.
- */
-[[nodiscard]] STAmount
-debitToPosteriorBrokerCoverScale(
-    SLE::ConstRef vault,
-    SLE::ConstRef broker,
-    STAmount const& amount,
-    Number::RoundingMode roundingMode);
-
-/**
- * Round a cover inflow (cover deposit, LoanPay's fee redirect into cover)
- * into CoverAvailable by flooring the sum rather than the delta:
- * credit = floor16(CoverAvailable + raw) - CoverAvailable, never finer
- * than the Vault's base exponent (-Scale). See
- * creditToPosteriorAvailableScale's doc for why the sum, not the delta,
- * must be floored; the same reasoning applies to CoverAvailable.
- */
-[[nodiscard]] STAmount
-creditToPosteriorBrokerCoverScale(
-    SLE::ConstRef vault,
-    SLE::ConstRef broker,
-    Number const& raw,
-    Number::RoundingMode roundingMode);
-
-/**
- * Check whether amount is an admissible optional cover inflow.
- *
- * Legacy and CashBasis Vaults always succeed. A LoanBroker attached to a
- * FixedPrecision Vault must remain at the Vault's base scale after applying
- * the rounded amount, and its posterior CoverAvailable must stay within the
- * Open zone.
- *
- * LoanPay's fee redirect into cover is a mandatory inflow and does not call
- * this check, so it can push CoverAvailable past the Open zone limit this
- * check enforces. Once that happens, every subsequent LoanBrokerCoverDeposit
- * returns tecLIMIT_EXCEEDED until the owner withdraws cover back under the
- * limit; LoanBrokerCoverWithdraw and LoanBrokerCoverClawback are unaffected.
- */
-[[nodiscard]] TER
-checkOptionalBrokerCoverInflow(SLE::ConstRef vault, SLE::ConstRef broker, STAmount const& amount);
-
 // Lending protocol has dependencies, so capture them here.
 bool
 checkLendingProtocolDependencies(Rules const& rules, STTx const& tx);
@@ -140,13 +64,13 @@ checkLendingProtocolDependencies(Rules const& rules, STTx const& tx);
  * The accounts and asset that LoanManage::defaultLoan's fixCleanup3_4_0
  * freeze/lock exemption applies to.
  *
- * defaultLoan moves funds from the LoanBroker pseudo-account to the Vault
- * pseudo-account via accountSend. Since neither is the vault asset's
+ * `defaultLoan` moves funds from the LoanBroker pseudo-account to the Vault
+ * pseudo-account via `accountSend`. Since neither is the vault asset's
  * issuer, this is a third-party transfer that transits through the issuer in
  * two hops (broker -> issuer, issuer -> vault; see
- * directSendNoLimitIOU/directSendNoLimitMPT), so the exemption must cover
+ * `directSendNoLimitIOU`/`directSendNoLimitMPT`), so the exemption must cover
  * both the issuer/broker and issuer/vault pairs, not a direct broker/vault
- * pair. asset scopes it further to the vault's own currency/MPT issuance,
+ * pair. `asset` scopes it further to the vault's own currency/MPT issuance,
  * so an unrelated one the same accounts happen to hold is still protected.
  */
 struct LoanDefaultFreezeExemptAccounts
@@ -164,10 +88,10 @@ struct LoanDefaultFreezeExemptAccounts
  * @param view Ledger view used to resolve the Loan -> LoanBroker -> Vault
  * chain.
  * @param tx The transaction under invariant review.
- * @return The exempt accounts and asset if tx is a ttLOAN_MANAGE
- * transaction with the tfLoanDefault flag set, fixCleanup3_4_0 is
+ * @return The exempt accounts and asset if `tx` is a `ttLOAN_MANAGE`
+ * transaction with the `tfLoanDefault` flag set, `fixCleanup3_4_0` is
  * enabled, and the loan/broker/vault objects it references can all be
- * resolved; std::nullopt otherwise.
+ * resolved; `std::nullopt` otherwise.
  */
 [[nodiscard]] std::optional<LoanDefaultFreezeExemptAccounts>
 getLoanDefaultFreezeExemptAccounts(ReadView const& view, STTx const& tx);
@@ -330,38 +254,28 @@ adjustImpreciseNumber(
         value = 0;
 }
 
-/**
- * Apply a signed delta to a LoanBroker's DebtTotal: on FixedPrecision Vaults,
- * add the exact delta (DebtTotal moves by exactly the same amount as the
- * Vault's AssetsDeployed, never re-rounded); on Legacy/CashBasis Vaults,
- * round through adjustImpreciseNumber at vaultScale. Shared by LoanSet
- * (origination) and LoanPay (payment, where delta is negative).
- *
- * @param brokerSle The LoanBroker whose DebtTotal is adjusted.
- * @param vaultSle The LoanBroker's Vault.
- * @param delta The signed change to DebtTotal.
- * @param vaultScale The Vault scale the caller captured before changing
- *        AssetsTotal. Legacy/CashBasis round DebtTotal at that scale, not at
- *        the scale after this transaction's AssetsTotal change. Unused on
- *        FixedPrecision Vaults.
- */
-void
-adjustBrokerDebtTotal(
-    SLE::Ref brokerSle,
-    SLE::ConstRef vaultSle,
-    Number const& delta,
-    int vaultScale);
+inline int
+getAssetsTotalScale(SLE::ConstRef vaultSle)
+{
+    if (!vaultSle)
+        return Number::kMinExponent - 1;  // LCOV_EXCL_LINE
+    return scale(vaultSle->at(sfAssetsTotal), vaultSle->at(sfAsset));
+}
 
-/**
- * Minimum required broker cover, rounded up.
- *
- * DebtTotal is a broker-level aggregate, never rounded at an individual
- * loan's scale. Legacy and CashBasis Vaults round at the live AssetsTotal
- * exponent. FixedPrecision Vaults round at the Vault's base exponent
- * (-Scale, or 0 for integral assets).
- */
-Number
-minimumBrokerCover(Number const& debtTotal, TenthBips32 coverRateMinimum, SLE::ConstRef vaultSle);
+// Compute the minimum required broker cover, rounded consistently.
+// DebtTotal is a broker-level aggregate maintained at vault scale, so the
+// rounding must also use vault scale — never an individual loan's scale.
+inline Number
+minimumBrokerCover(Number const& debtTotal, TenthBips32 coverRateMinimum, SLE::ConstRef vaultSle)
+{
+    XRPL_ASSERT(
+        vaultSle && vaultSle->getType() == ltVAULT, "xrpl::minimumBrokerCover : valid Vault sle");
+    NumberRoundModeGuard const mg(Number::RoundingMode::Upward);
+    return roundToAsset(
+        vaultSle->at(sfAsset),
+        tenthBipsOfValue(debtTotal, coverRateMinimum),
+        getAssetsTotalScale(vaultSle));
+}
 
 TER
 checkLoanGuards(
@@ -465,10 +379,10 @@ loanPaymentDeltas(LoanPaymentParts const& parts);
 
 }  // namespace cash_basis
 
-// Public dispatchers: pick cash_basis:: if the Vault's LEVersion
-// (VaultHelpers::getVaultVersion) is CashBasis or later (CashBasis or
-// FixedPrecision), else instant_recognition::. These are the only entry
-// points transactors call.
+// Public dispatchers: pick cash_basis:: if featureLendingProtocolV1_1 is
+// enabled AND the Vault's LEVersion (VaultHelpers::getVaultVersion) is
+// VaultVersion::CashBasis, else instant_recognition::. These are the only entry points
+// transactors call.
 AccountingDeltas
 loanOriginationDeltas(
     SLE::ConstRef vaultSle,

include/xrpl/ledger/helpers/MPTokenHelpers.h

@@ -312,22 +312,12 @@ checkCreateMPT(
 //
 //------------------------------------------------------------------------------
 
-/**
- * MaximumAmount doesn't exceed 2**63-1
- */
+// MaximumAmount doesn't exceed 2**63-1
 std::int64_t
 maxMPTAmount(SLE const& sleIssuance);
 
-/**
- * std::nullopt if the issuance doesn't exist.
- */
-std::optional<std::int64_t>
-maxMPTAmount(ReadView const& view, MPTID const& mptID);
-
-/**
- * OutstandingAmount may overflow and available amount might be negative.
- * But available amount is always <= |MaximumAmount - OutstandingAmount|.
- */
+// OutstandingAmount may overflow and available amount might be negative.
+// But available amount is always <= |MaximumAmount - OutstandingAmount|.
 std::int64_t
 availableMPTAmount(SLE const& sleIssuance);
 
@@ -341,12 +331,7 @@ availableMPTAmount(ReadView const& view, MPTID const& mptID);
  * directSendNoFee transactions that bypass the payment engine.
  * 2.  **accountSend & Payment Engine (Overflow: Yes):** A temporary overflow
  * check when `OutstandingAmount > UINT64_MAX`. This higher threshold is used
- * for `accountSend` and payments processed via the payment engine, whose
- * reverse pass may issue before it redeems.
- *
- * In both cases a single `sendAmount > MaximumAmount` is rejected. Such a send
- * can never settle: redemptions within the transaction are bounded by the
- * outstanding amount, so the final OutstandingAmount would exceed the cap.
+ * for `accountSend` and payments processed via the payment engine.
  */
 bool
 isMPTOverflow(
@@ -368,12 +353,6 @@ issuerFundsToSelfIssue(ReadView const& view, MPTIssue const& issue);
 /**
  * Facilitate tracking of MPT sold by an issuer owning MPT sell offer.
  * See ApplyView::issuerSelfDebitHookMPT().
- *
- * `amount` may be 0. BookStep removes an offer whose fee-adjusted funded
- * output is 0, but other clips (for example MaximumAmount via limitStepIn)
- * can still consume a zero slice of a funded remainder. The hook must
- * accept 0: first call still snapshots origBalance; a zero debit adds
- * nothing to selfDebit.
  */
 void
 issuerSelfDebitHookMPT(ApplyView& view, MPTIssue const& issue, std::uint64_t amount);

include/xrpl/ledger/helpers/ProposalHelpers.h

@@ -1,17 +1,10 @@
 #pragma once
 
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/SField.h>
-#include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/STObject.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFormats.h>
 
 #include <cstdint>
-#include <optional>
 
 namespace xrpl::proposal {
 
@@ -38,21 +31,30 @@ proposalOwnerCount(STObject const& proposedTx)
 }
 
 /**
- * Whether the proposed transaction is independently submittable through the
- * ordinary multi-sign path: not a proposal transaction itself, not a
- * pseudo-transaction, not itself flagged as someone else's inner batch
- * transaction, and — if it is a Batch — every one of its own inner
- * transactions carries a TransactionType and is neither a proposal, a
- * pseudo-transaction, nor a nested Batch. A Batch inner transaction cannot
- * lack a TransactionType, be pseudo, or be a nested Batch (STTx construction
- * rejects a typeless inner and an inner Batch, and preflight0 rejects the
- * pseudo/tfInnerBatchTxn combination), but those guards live outside this
- * feature, so they are checked again here rather than relied upon.
+ * Whether the proposed transaction is itself a proposal transaction, which
+ * would nest one proposal inside another.
  *
- * TODO: cover ttTRANSACTION_PROPOSAL_SIGN once that transaction exists.
+ * TODO: cover ttTRANSACTION_PROPOSAL_SIGN and ttTRANSACTION_PROPOSAL_CANCEL
+ * once those transactions exist.
+ */
+inline bool
+isProposalTx(STObject const& proposedTx)
+{
+    return proposedTx.getFieldU16(sfTransactionType) == ttTRANSACTION_PROPOSAL_CREATE;
+}
+
+/**
+ * Whether the proposed transaction is independently submittable through the
+ * ordinary multi-sign path: not a nested proposal, not a pseudo-transaction,
+ * not itself flagged as someone else's inner batch transaction, and — if it
+ * is a Batch — none of its own inner transactions is a nested proposal or a
+ * pseudo-transaction either. A Batch inner transaction cannot itself be
+ * pseudo (preflight0 rejects the pseudo/tfInnerBatchTxn combination
+ * generically), but that guard lives outside this feature, so it is checked
+ * again here rather than relied upon.
  */
 bool
-isValidProposalTxnType(STObject const& proposedTx);
+isValidProposal(STObject const& proposedTx);
 
 /**
  * Whether the proposed transaction carries any signature field.
@@ -82,93 +84,4 @@ hasEmptySigningPubKey(STObject const& proposedTx)
         proposedTx.getFieldVL(sfSigningPubKey).empty();
 }
 
-/**
- * Whether the proposal is terminal (On-Chain Cosigner spec §4.5). A terminal proposal
- * stops accepting signatures and anyone may delete it. An already signed
- * payload can still execute after Expiration, because the Ticket reservation
- * compares payloads only; a passed LastLedgerSequence does stop it.
- *
- * A proposal is terminal when either:
- * - its Expiration has passed (the parent ledger closed at or after it), or
- * - the proposed transaction carries a LastLedgerSequence and the current
- *   ledger sequence is strictly greater than it. This mirrors the ordinary
- *   transactor's tefMAX_LEDGER rule: at view.seq() == LastLedgerSequence the
- *   payload can still be submitted in the current ledger, so the proposal is
- *   still live.
- *
- * @param view The ledger the deciding transaction is being applied to.
- * @param expiration The proposal's Expiration field.
- * @param proposedTx The proposal's ProposedTransaction field.
- */
-bool
-isTerminal(
-    ReadView const& view,
-    std::optional<std::uint32_t> expiration,
-    STObject const& proposedTx);
-
-/**
- * Delete a TransactionProposal ledger entry.
- *
- * Removes the entry from its Owner's directory, releases the reserve the
- * proposal holds against the Owner, and erases the entry. Shared by every
- * deletion path the spec defines (On-Chain Cosigner spec §4.5): automatic cleanup when the
- * proposed transaction's TicketSequence is consumed, and the
- * TransactionProposalCancel / TransactionProposalSign cleanup paths once
- * those transactions exist.
- *
- * The release goes through decreaseOwnerCountForObject, so it follows the
- * sfSponsor an entry created with reserve sponsorship carries: the reserve is
- * returned to whoever was holding it, the Owner or that sponsor.
- *
- * @param view The apply view for making changes
- * @param sleProposal The TransactionProposal ledger entry to delete
- * @param j Journal for logging
- * @return tesSUCCESS, tecINTERNAL for an invalid entry, or tefBAD_LEDGER if
- *         the ledger contradicts the entry
- */
-TER
-deleteProposal(ApplyView& view, SLE::pointer const& sleProposal, beast::Journal j);
-
-/**
- * Whether tx carries the same payload as a proposal's stored
- * ProposedTransaction (On-Chain Cosigner spec §4.2.1).
- *
- * The payload is the signing payload: the fields the collected signatures
- * commit to. Compared is every field except those flagged kNotSigning
- * (TxnSignature, Signers, BatchSigners, CounterpartySignature,
- * SponsorSignature, Signature, MasterSignature) and SigningPubKey, which is
- * stored empty and filled only if the target signs with its own key. So the
- * completed transaction matches no matter which mix of collected or
- * off-ledger signatures it carries, and any change to a non-signature field
- * results in a false-return value.
- *
- * Signature (PaymentChannelClaim) is deliberately not compared: it is
- * outside the account's own TxnSignature even for an ordinary submission, so
- * a proposal cannot bind it more tightly than the signatures it collects do,
- * and that transactor still validates a substituted value exactly as it would
- * for an ordinary submission.
- * MasterSignature appears in no transaction format.
- *
- * @param proposedTx The proposal's ProposedTransaction field.
- * @param tx The transaction to compare, typically an STTx.
- */
-bool
-payloadMatches(STObject const& proposedTx, STObject const& tx);
-
-/**
- * Whether tx may consume its Ticket.
- *
- * While a proposal keyed to the Ticket exists, the target's Ticket is
- * reserved: only the proposal's own proposed transaction may spend it
- * (On-Chain Cosigner spec §4.2.1), so that unrelated target-account activity cannot
- * invalidate the proposal while signatures are being collected.
- * TransactionProposalCancel is not allowed through: it deletes the
- * reservation without consuming the ticket.
- *
- * @param view The ledger containing the Ticket and any reservation.
- * @param tx The transaction attempting to consume that ticket.
- */
-bool
-canConsumeTicket(ReadView const& view, STTx const& tx);
-
 }  // namespace xrpl::proposal

include/xrpl/ledger/helpers/TokenHelpers.h

@@ -316,20 +316,6 @@ transferRate(ReadView const& view, Asset const& asset);
 [[nodiscard]] Rate
 transferRate(ReadView const& view, STAmount const& amount);
 
-/**
- * Returns the amount a sender must part with for `amount` to reach the
- * receiver once the issuer takes the transfer fee. Rounds up.
- */
-[[nodiscard]] STAmount
-addTransferFee(STAmount const& amount, Rate const& rate);
-
-/**
- * Returns the amount a receiver gets when `amount` leaves the sender and the
- * issuer takes the transfer fee. Rounds down.
- */
-[[nodiscard]] STAmount
-subtractTransferFee(STAmount const& amount, Rate const& rate);
-
 //------------------------------------------------------------------------------
 //
 // Holding operations (Asset-based dispatchers)

include/xrpl/ledger/helpers/VaultHelpers.h

@@ -1,12 +1,10 @@
 #pragma once
 
 #include <xrpl/basics/Number.h>
-#include <xrpl/beast/utility/Journal.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Asset.h>
 #include <xrpl/protocol/Protocol.h>
-#include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/TER.h>
@@ -14,239 +12,11 @@
 #include <cstdint>
 #include <expected>
 #include <optional>
-#include <string_view>
 
 namespace xrpl {
 
 class STTx;
 
-/**
- * @brief Return the Vault's current assets total.
- *
- * FixedPrecision Vaults return AssetsAvailable plus AssetsDeployed, with no
- * rounding to the asset's 16-digit precision: the sum is exact at Number's
- * active 19-digit mantissa width (the large mantissa range, enabled by
- * featureSingleAssetVault or featureLendingProtocol), rounds Downward regardless of the
- * caller's ambient mode beyond that, and is not rounded to match the cached
- * sfAssetsTotal field. Legacy and CashBasis Vaults return the stored
- * AssetsTotal.
- *
- * @param vault The vault SLE.
- * @return The current assets total.
- */
-[[nodiscard]] Number
-getAssetsTotal(SLE::ConstRef vault);
-
-/**
- * @brief A change to a FixedPrecision Vault's balances.
- */
-struct VaultBalanceChange
-{
-    /**
-     * Signed change to AssetsAvailable. Must be the exact amount moved on the
-     * Vault pseudo-account in the same transaction. Absent means no cash
-     * moved; adjustVaultBalances then uses zero of the Vault's own asset.
-     */
-    std::optional<STAmount> cash = std::nullopt;
-
-    /**
-     * Signed change to AssetsDeployed: open Loan principal, exact.
-     */
-    Number deployed = 0;
-
-    /**
-     * Signed change to scheduled, unpaid interest (YieldUnrealized), exact.
-     */
-    Number yield = 0;
-
-    /**
-     * Signed change to impaired principal (LossUnrealized), exact.
-     */
-    Number loss = 0;
-};
-
-/**
- * @brief Apply a balance change to a FixedPrecision Vault. The only writer of
- * AssetsAvailable, AssetsDeployed, AssetsTotal, YieldUnrealized and
- * LossUnrealized on these Vaults after creation.
- *
- * @param vault The vault SLE. Must be FixedPrecision.
- * @param change The balance change to apply.
- * @param j Journal for logging the fatal (tefBAD_LEDGER) case.
- *
- * @return tesSUCCESS; tecLIMIT_EXCEEDED if LossUnrealized would exceed
- *         AssetsDeployed; tefBAD_LEDGER if AssetsAvailable, AssetsDeployed,
- *         LossUnrealized or YieldUnrealized would become negative.
- */
-[[nodiscard]] TER
-adjustVaultBalances(SLE::Ref vault, VaultBalanceChange const& change, beast::Journal j);
-
-/**
- * @brief Apply a signed cash movement to a Vault of any version. FixedPrecision
- * Vaults go through adjustVaultBalances; Legacy and CashBasis Vaults add the
- * amount to both AssetsTotal and AssetsAvailable.
- *
- * @param vault The vault SLE.
- * @param delta Signed change to AssetsAvailable; the exact amount moved on the
- *              Vault pseudo-account.
- * @param j Journal passed through to adjustVaultBalances.
- *
- * @return tesSUCCESS, or the adjustVaultBalances error for FixedPrecision Vaults.
- */
-[[nodiscard]] TER
-adjustVaultCash(SLE::Ref vault, STAmount const& delta, beast::Journal j);
-
-/**
- * Return the Vault's current live exponent.
- *
- * Legacy and CashBasis Vaults use the exponent of AssetsTotal. FixedPrecision
- * Vaults use max(base exponent, exponent of AssetsTotal): the grid is never
- * finer than -Scale and coarsens once AssetsTotal outgrows 16 digits there.
- */
-[[nodiscard]] int
-getVaultScale(SLE::ConstRef vault);
-
-/**
- * Return the Vault's base exponent.
- *
- * Legacy and CashBasis Vaults use their current live exponent. FixedPrecision
- * Vaults use -Scale, or 0 for integral assets.
- */
-[[nodiscard]] int
-getVaultBaseScale(SLE::ConstRef vault);
-
-/**
- * Round an amount at the Vault's posterior live exponent.
- */
-[[nodiscard]] STAmount
-roundToPosteriorVaultScale(
-    SLE::ConstRef vault,
-    STAmount const& amount,
-    Number::RoundingMode roundingMode);
-
-namespace detail {
-
-/**
- * Return the Vault's posterior live exponent after applying an unrounded delta.
- */
-[[nodiscard]] int
-getPosteriorVaultScale(SLE::ConstRef vault, STAmount const& delta);
-
-/**
- * Shared grid-floor core of getVaultScale / getPosteriorVaultScale /
- * getPosteriorBrokerCoverScale: baseScale when reference is zero, otherwise
- * max(baseScale, scale(reference, asset)), rounded Downward regardless of
- * the caller's ambient rounding mode.
- */
-[[nodiscard]] int
-liveScale(Number const& reference, Asset const& asset, int baseScale);
-
-/**
- * Shared core of getPosteriorVaultScale and getPosteriorBrokerCoverScale:
- * the exponent reference + delta would have under version's live-scale rule
- * (floored at baseScale for FixedPrecision, unbounded for Legacy/CashBasis).
- *
- * @param version The Vault's LEVersion.
- * @param asset The Vault's underlying asset.
- * @param baseScale The Vault's base exponent; unused outside the
- *                   FixedPrecision case.
- * @param reference The balance the delta is applied to (AssetsAvailable,
- *                   AssetsTotal, or a LoanBroker's CoverAvailable).
- * @param delta The unrounded change to reference.
- */
-[[nodiscard]] int
-posteriorAssetScale(
-    VaultVersion version,
-    Asset const& asset,
-    int baseScale,
-    Number const& reference,
-    Number const& delta);
-
-/**
- * Shared core of creditToPosteriorAvailableScale and
- * creditToPosteriorBrokerCoverScale: floors reference + raw at the sum's
- * own live scale (never finer than baseScale) and returns the difference
- * from reference, so the delta applied is exactly what moves reference onto
- * the floored sum. See creditToPosteriorAvailableScale's doc for why the
- * sum, not raw alone, must be floored. raw is the exact amount; it is not
- * rounded on its own before being added to reference. The sum and its scale
- * are computed once, in roundingMode, so a Downward credit is always
- * between zero and raw.
- */
-[[nodiscard]] STAmount
-creditToPosteriorScale(
-    Asset const& asset,
-    Number const& reference,
-    int baseScale,
-    Number const& raw,
-    Number::RoundingMode roundingMode);
-
-}  // namespace detail
-
-/**
- * Round a FixedPrecision cash inflow (LoanPay's credit, LoanManage's
- * default cover credit) into AssetsAvailable, never AssetsTotal, which is
- * a derived cache, by flooring the sum rather than the delta:
- * credit equals floor16(AssetsAvailable + raw) minus AssetsAvailable, never
- * finer than the Vault's base exponent (-Scale).
- *
- * Flooring only the delta at its own posterior grid is not enough: the sum
- * can still need a 17th digit when AssetsAvailable is off the coarser grid
- * right after crossing a power of ten. Example at Scale 6: AssetsAvailable
- * equals 9999999999.999999 (16 digits already) and a credit of 0.000011
- * floors to 0.00001 on its own (finer) grid, but 9999999999.999999 plus
- * 0.00001 equals 10000000000.000009, which still needs 17 digits. Flooring
- * the sum instead, floor16(9999999999.999999 + 0.000011) minus
- * 9999999999.999999, is exact by construction, since STAmount's own
- * 16-digit canonical form of the sum is what gets subtracted from.
- *
- * raw is taken as an exact Number: rounding it to 16 digits before adding
- * it to AssetsAvailable could drop a tail that moves the floored sum.
- */
-[[nodiscard]] STAmount
-creditToPosteriorAvailableScale(
-    SLE::ConstRef vault,
-    Number const& raw,
-    Number::RoundingMode roundingMode);
-
-/**
- * Open-zone capacity ceiling: 9 * 10^(15 + baseScale).
- *
- * Defined only for FixedPrecision Vaults, where this is 9 * 10^(15 - P).
- */
-[[nodiscard]] Number
-getVaultOpenLimit(SLE::ConstRef vault);
-
-/**
- * Check whether amount is an admissible optional inflow.
- *
- * Legacy and CashBasis Vaults always succeed. FixedPrecision Vaults must
- * remain at their base scale after applying the rounded amount, and the
- * posterior capacity (AssetsTotal + YieldUnrealized + rounded amount) must
- * stay within the Open zone.
- *
- * The amount is rounded toward zero at the posterior live exponent.
- */
-[[nodiscard]] TER
-checkOptionalVaultInflow(SLE::ConstRef vault, STAmount const& amount);
-
-/**
- * Open-zone capacity after adding roundedAmount: AssetsTotal + YieldUnrealized
- * + roundedAmount, computed TowardsZero regardless of the caller's ambient
- * rounding mode. Defined only for FixedPrecision Vaults.
- *
- * Shared by checkOptionalVaultInflow and LoanSet's loan-origination capacity
- * check, which pair this formula with different scale checks (posterior vs.
- * current), so only the capacity formula itself -- not the whole check -- is
- * shared here.
- *
- * @param vault The vault SLE. Must be FixedPrecision.
- * @param roundedAmount The amount to add, already rounded to the relevant
- *                       posterior or base scale by the caller.
- */
-[[nodiscard]] Number
-vaultOpenZoneCapacity(SLE::ConstRef vault, Number const& roundedAmount);
-
 /**
  * From the perspective of a vault, return the number of shares to give
  * depositor when they offer a fixed amount of assets. Note, since shares are
@@ -276,93 +46,31 @@ assetsToSharesDeposit(SLE::ConstRef vault, SLE::ConstRef issuance, STAmount cons
 sharesToAssetsDeposit(SLE::ConstRef vault, SLE::ConstRef issuance, STAmount const& shares);
 
 /**
- * Adjusts a requested asset change (delta) to match the decimal scale of the
- * updated total vault assets. This ensures sfAssetsTotal, sfAssetsAvailable,
+ * Adjusts a requested asset change (`delta`) to match the decimal scale of the
+ * updated total vault assets. This ensures `sfAssetsTotal`, `sfAssetsAvailable`,
  * and the actual asset transfer change by the exact same representable amount.
  *
  * Rounding strategy:
- * - Legacy/CashBasis debits (withdrawals): rounds down the magnitude of delta
- *   on the new scale to prevent paying out more than requested.
- * - Legacy/CashBasis credits: floors the resulting total asset balance and
- *   returns the difference from the current total.
- * - FixedPrecision credits only (VaultDeposit): rounds the delta toward zero
- *   at the scale getAssetsTotal (AssetsAvailable + AssetsDeployed, derived,
- *   not the stored AssetsTotal cache) would have after applying delta.
- *   FixedPrecision outflows (VaultWithdraw, VaultClawback) never call this;
- *   they use clampVaultOutflow instead.
+ * - Debits (withdrawals): Rounds down `|delta|` on the new scale to prevent
+ *   paying out more than requested.
+ * - Credits (deposits): Floors the resulting total asset balance and returns the
+ *   difference from the current total. This prevents crediting the vault with
+ *   more assets than the user deposited.
  *
  * Key rules:
- * - The returned magnitude never exceeds the magnitude of delta.
- * - Returns tecPRECISION_LOSS if the change is smaller than 1 ULP of the target scale
+ * - The returned magnitude never exceeds `|delta|`.
+ * - Returns `tecPRECISION_LOSS` if the change is smaller than 1 ULP of the target scale
  *   (prevents share operations when totals cannot change).
  * - For integer assets (XRP, MPT), rounding is a no-op.
  *
  * @param vault The vault ledger entry.
  * @param delta The requested signed change to sfAssetsTotal.
- * @return The rounded, positive magnitude, or tecPRECISION_LOSS if the
+ * @return The rounded, positive magnitude, or `tecPRECISION_LOSS` if the
  *         change is below representable precision.
  */
 [[nodiscard]] std::expected<STAmount, TER>
 clampToAssetsTotalScale(SLE::ConstRef vault, STAmount const& delta);
 
-/**
- * Outflow clamp dispatcher for VaultWithdraw and VaultClawback: rounds a
- * negative delta to the scale appropriate for the Vault's version -- for
- * FixedPrecision, at AssetsAvailable's own posterior scale (the balance the
- * cash actually leaves); for Legacy/CashBasis, clampToAssetsTotalScale --
- * so both call sites share one dispatch point. Same tecPRECISION_LOSS and
- * integral-asset and magnitude-never-exceeds-delta rules as
- * clampToAssetsTotalScale.
- *
- * @param vault The vault ledger entry.
- * @param delta The requested signed outflow (negative).
- * @return The rounded, positive magnitude, or tecPRECISION_LOSS if the
- *         change is below representable precision.
- */
-[[nodiscard]] std::expected<STAmount, TER>
-clampVaultOutflow(SLE::ConstRef vault, STAmount const& delta);
-
-/**
- * Returns the Vault's base exponent for asset at scale, before a Vault
- * object exists to read it from: 0 for an integral asset, -scale otherwise.
- * Used by VaultCreate::preclaim, which only has the proposed Scale field,
- * not yet a Vault SLE; getVaultBaseScale is the post-creation equivalent.
- *
- * @param asset The (prospective) Vault's underlying asset.
- * @param scale The (prospective) Vault's sfScale value, ignored for
- *              integral assets.
- */
-[[nodiscard]] int
-vaultBaseScale(Asset const& asset, std::uint8_t scale);
-
-/**
- * Returns true iff value is exactly representable both as an STAmount of
- * asset and on the base grid at baseScale (no precision lost rounding
- * TowardsZero at baseScale). Returns false, rather than throwing, for a value
- * out of range for the asset. Shared representability check for
- * VaultCreate::preclaim, VaultSet::preclaim and LoanBrokerSet::preclaim's
- * AssetsMaximum / DebtMaximum / cover-rate field checks.
- *
- * @param asset The vault's underlying asset.
- * @param value The value to check.
- * @param baseScale The vault's base exponent (see vaultBaseScale /
- *                  getVaultBaseScale).
- */
-[[nodiscard]] bool
-isOnVaultBaseGrid(Asset const& asset, Number const& value, int baseScale);
-
-/**
- * Checks that a requested AssetsMaximum is exactly representable on the
- * Vault's base grid, otherwise associateAsset would silently round the cap
- * the owner asked for. Used by VaultSet::preclaim on an existing Vault.
- *
- * @param vault The vault ledger entry.
- * @param amount The requested AssetsMaximum.
- * @return tesSUCCESS, or tecPRECISION_LOSS if amount is not representable.
- */
-[[nodiscard]] TER
-checkAssetsMaximum(SLE::ConstRef vault, Number const& amount);
-
 /**
  * Controls whether to truncate shares instead of rounding.
  */
@@ -390,24 +98,21 @@ enum class WaiveUnrealizedLoss : bool { No = false, Yes = true };
 assetsTotalForWithdrawal(SLE::ConstRef vault, WaiveUnrealizedLoss waive);
 
 /**
- * Reject a cash outflow that is dust (see debitIsNonZeroDust) or whose check
- * overflows Number, which is easy to hit with a large Scale.
+ * Returns true if debiting `amount` from `total` (the current value of a
+ * vault's sfAssetsTotal or sfAssetsAvailable) would canonicalize to the
+ * same STAmount value. This happens when `amount` is non-zero but too small
+ * to change the stored total at STAmount's precision. Shares would still
+ * move, so the ValidVault invariant would fail after apply; callers use
+ * this to reject the transaction upfront instead.
  *
- * @param vault The vault SLE.
- * @param amount The amount to debit.
- * @param j Journal for the debug log.
- * @param name Transaction name used as the log prefix.
- *
- * @return tesSUCCESS; tecPRECISION_LOSS if amount is dust; tecPATH_DRY if the
- *         check overflows. Overflow means the transaction cannot apply, but
- *         ledger state is still consistent.
+ * @param asset The vault's underlying asset, used to canonicalize both
+ *              sides the same way the ledger will when the field is stored.
+ * @param total The field's current value.
+ * @param amount The amount to debit. Zero always returns false; that case
+ *               is rejected separately.
  */
-[[nodiscard]] TER
-checkDebitNotDust(
-    SLE::ConstRef vault,
-    Number const& amount,
-    beast::Journal j,
-    std::string_view name);
+[[nodiscard]] bool
+debitIsNonZeroDust(Asset const& asset, Number const& total, Number const& amount);
 
 /**
  * From the perspective of a vault, return the number of shares to demand from
@@ -453,7 +158,7 @@ sharesToAssetsWithdraw(
     WaiveUnrealizedLoss waive = WaiveUnrealizedLoss::No);
 
 /**
- * Returns true iff account holds all of the vault's outstanding shares,
+ * Returns true iff `account` holds all of the vault's outstanding shares —
  * i.e. is the sole remaining shareholder. Returns false if the account
  * holds no shares or fewer than the total outstanding.
  *
@@ -466,13 +171,11 @@ sharesToAssetsWithdraw(
 isSoleShareholder(ReadView const& view, AccountID const& account, SLE::ConstRef issuance);
 
 /**
- * Resolves a Vault's LEVersion.
- *
- * LEVersion is the single point every accounting and rounding helper
- * should call to decide which protocol a Vault follows. It is written
- * at VaultCreate and is not updated afterwards, so a Vault created
- * under an older amendment keeps that behaviour after later amendments
- * activate. Absent sfLEVersion resolves to VaultVersion::Legacy.
+ * Resolves a Vault's LEVersion, the single point every accounting touch
+ * point should call to determine which recognition model (instant interest
+ * recognition vs. cash-basis) a Vault uses. Vaults created before featureLendingProtocolV1_1
+ * activated never have sfLEVersion set, which resolves here to
+ * VaultVersion::Legacy.
  *
  * @param vault The vault SLE.
  *
@@ -482,34 +185,6 @@ isSoleShareholder(ReadView const& view, AccountID const& account, SLE::ConstRef
 [[nodiscard]] VaultVersion
 getVaultVersion(SLE::ConstRef vault);
 
-/**
- * Decodes an already-extracted sfLEVersion value with the same range check as
- * getVaultVersion. Usable from contexts, such as an invariant's ledger-entry
- * snapshot, that keep the field value but not the owning SLE.
- *
- * @param leVersion The value of sfLEVersion, or nullopt if absent.
- *
- * @return The decoded LEVersion, or VaultVersion::Legacy if absent.
- */
-[[nodiscard]] VaultVersion
-decodeVaultVersion(std::optional<std::uint8_t> leVersion);
-
-/**
- * Resolves which LEVersion a newly-created Vault should get under the
- * currently active amendments. This is the only place that decides Vault
- * version policy; VaultCreate calls it instead of checking amendments
- * directly.
- *
- * @param rules The active ledger rules.
- *
- * @return VaultVersion::FixedPrecision once featureLendingProtocolV1_1,
- * featureLendingProtocolV1_2 and fixCleanup3_4_0 are all enabled;
- * VaultVersion::CashBasis
- * once featureLendingProtocolV1_1 is enabled; VaultVersion::Legacy otherwise.
- */
-[[nodiscard]] VaultVersion
-getVaultDefaultVersion(Rules const& rules);
-
 /**
  * Resolves the VaultKind of a vault SLE. Returns VaultKind::ClosedEnded when
  * sfVaultKind is present and equal to that value; anything else (including an

include/xrpl/protocol/ApiVersion.h

@@ -6,31 +6,25 @@
 #include <xrpl/protocol/jss.h>
 
 #include <cstddef>
+#include <string_view>
 #include <type_traits>
 #include <utility>
 
 namespace xrpl {
 
 /**
- * API version numbers used in later API versions
+ * The `api_version` numbers this server serves.
  *
- * Requests with a version number in the range
- * [apiMinimumSupportedVersion, apiMaximumSupportedVersion]
- * are supported.
+ * A request naming a version in [kApiMinimumSupportedVersion,
+ * kApiMaximumSupportedVersion] is served. With `[beta_rpc_api]` set to `1` in
+ * the config the range extends to kApiBetaVersion.
  *
- * If [beta_rpc_api] is enabled in config, the version numbers
- * in the range [apiMinimumSupportedVersion, apiBetaVersion]
- * are supported.
- *
- * Network Requests without explicit version numbers use
- * apiVersionIfUnspecified. apiVersionIfUnspecified is 1,
- * because all the RPC requests with a version >= 2 must
- * explicitly specify the version in the requests.
- * Note that apiVersionIfUnspecified will be lower than
- * apiMinimumSupportedVersion when we stop supporting API
- * version 1.
- *
- * Command line Requests use apiCommandLineVersion.
+ * A request naming no version is served at kApiVersionIfUnspecified, which is 1
+ * because a request wanting any later version states it. A WebSocket message is
+ * one flat object and names it at its top level at every version. A JSON-RPC
+ * request names it in its parameters, or at its own top level: an entry of a
+ * `"method": "batch"` body at every version, a lone request from
+ * kApiMinimumSpecVersion up.
  */
 
 namespace rpc {
@@ -46,6 +40,31 @@ static constexpr auto kApiCommandLineVersion = kApiVersion<1>;  // TODO Bump to
 static constexpr auto kApiBetaVersion = kApiVersion<3>;
 static constexpr auto kApiMaximumValidVersion = kApiBetaVersion;
 
+/**
+ * First API version that follows the JSON-RPC 2.0 specification.
+ *
+ * From this version up a lone JSON-RPC request may state its `api_version` at
+ * its own top level, beside the members the specification defines there, as a
+ * WebSocket message always has. The member is an XRPL extension: the
+ * specification defines no version member.
+ *
+ * Distinct from kApiBetaVersion, the same number today, which says instead that
+ * the version needs [beta_rpc_api] to be reachable.
+ */
+static constexpr auto kApiMinimumSpecVersion = kApiVersion<3>;
+
+/**
+ * Whether @p apiVersion follows the JSON-RPC 2.0 specification.
+ *
+ * @param apiVersion The version a request asked for.
+ * @return Whether that version follows the specification.
+ */
+[[nodiscard]] constexpr bool
+isSpecVersion(unsigned apiVersion)
+{
+    return apiVersion >= kApiMinimumSpecVersion;
+}
+
 static_assert(kApiInvalidVersion < kApiMinimumSupportedVersion);
 static_assert(
     kApiVersionIfUnspecified >= kApiMinimumSupportedVersion &&
@@ -57,6 +76,16 @@ static_assert(kApiMaximumSupportedVersion >= kApiMinimumSupportedVersion);
 static_assert(kApiBetaVersion >= kApiMaximumSupportedVersion);
 static_assert(kApiMaximumValidVersion >= kApiMaximumSupportedVersion);
 
+/**
+ * Values accepted in the `ripplerpc` request field, which selects the shape of
+ * the JSON-RPC reply envelope. Distinct from `kJsonRpcVersion` in JsonRpc.h,
+ * which names the JSON-RPC protocol itself, and from the `api_version`
+ * constants above, which select the content of the response.
+ */
+inline constexpr std::string_view kRippleRpcVersion1{"1.0"};
+inline constexpr std::string_view kRippleRpcVersion2{"2.0"};
+inline constexpr std::string_view kRippleRpcVersion3{"3.0"};
+
 inline void
 setVersion(json::Value& parent, unsigned int apiVersion, bool betaEnabled)
 {

include/xrpl/protocol/ConfidentialTransfer.h

@@ -348,19 +348,16 @@ isAuditorMirrorCurrent(SLE const& issuance, SLE const& mptoken);
 areMirrorsCurrent(SLE const& issuance, SLE const& mptoken);
 
 /**
- * @brief Set the holder's issuer mirror epoch, and the issuer mirror key, to match the issuance's
- * current key.
+ * @brief Set the holder's issuer mirror epoch to match the issuance's current issuer key epoch.
  *
  * Call this after writing the issuer mirror ciphertext under the issuance's
  * currently registered issuer key, so that the mirror reads as current afterwards.
- * Also records sfIssuerMirrorEncryptionKey as the issuance's current issuer key
- * (both fields stay absent at epoch 0, where the original issuer key applies).
  *
  * @param issuance The MPTokenIssuance ledger object.
  * @param mptoken  The holder's MPToken ledger entry to update.
  */
 void
-setIssuerMirrorCurrent(SLE const& issuance, SLE& mptoken);
+setIssuerMirrorEpoch(SLE const& issuance, SLE& mptoken);
 
 /**
  * @brief Set the holder's auditor mirror epoch to match the issuance's current auditor key epoch.
@@ -375,18 +372,16 @@ void
 setAuditorMirrorEpoch(SLE const& issuance, SLE& mptoken);
 
 /**
- * @brief Set the holder's MPToken mirror epochs, and the issuer mirror key, to match the issuance's
- * current keys.
+ * @brief Set the holder's MPToken mirror epochs to match the issuance's current key epochs.
  *
  * Call this after writing mirror ciphertexts under the issuance's currently
- * registered keys, so that the mirrors read as current afterwards. Also records
- * sfIssuerMirrorEncryptionKey via setIssuerMirrorCurrent.
+ * registered keys, so that the mirrors read as current afterwards.
  *
  * @param issuance The MPTokenIssuance ledger object.
  * @param mptoken  The holder's MPToken ledger entry to update.
  */
 void
-setMirrorsCurrent(SLE const& issuance, SLE& mptoken);
+setMirrorEpochs(SLE const& issuance, SLE& mptoken);
 
 /**
  * @brief Verifies revealed amount encryptions for all recipients.

include/xrpl/protocol/ErrorCodes.h

@@ -3,6 +3,7 @@
 #include <xrpl/json/json_value.h>
 
 #include <string>
+#include <string_view>
 
 namespace xrpl {
 
@@ -144,7 +145,58 @@ enum ErrorCodeI {
     RpcEntryNotFound = 98,
     RpcUnexpectedLedgerType = 99,
 
-    RpcLast = RpcUnexpectedLedgerType,  // rpcLAST should always equal the last code.
+    // submit + simulate
+    RpcInvalidTransaction = 100,
+    RpcInternalSubmit = 101,
+    RpcInternalJson = 102,
+    RpcInternalSimulate = 103,
+
+    // transaction_entry
+    RpcFieldNotFoundTransaction = 104,
+    RpcNotYetImplemented = 105,
+    RpcTransactionNotFound = 106,
+
+    // transaction_entry + ledger_entry
+    RpcMalformedRequest = 107,
+
+    // ledger_accept
+    RpcNotStandAlone = 108,
+
+    // ledger_entry, API version 1 only
+    RpcUnknownOption = 109,
+
+    // ledger_entry field validation, one code per malformed field. The ledger_entry helpers report
+    // invalidParams (31) for all of them, so each token needs a row of its own. Alphabetical by
+    // token here only: the enum is append-only once a code ships.
+    //
+    // `malformedIssue` duplicates `issueMalformed` (93): same message, same status, two tokens,
+    // both on the wire already. Do not add a third spelling.
+    RpcMalformedAccount = 110,
+    RpcMalformedAddress = 111,
+    RpcMalformedAuthorized = 112,
+    RpcMalformedAuthorizedCredentials = 113,
+    RpcMalformedBridgeAccount = 114,
+    RpcMalformedBroker = 115,
+    RpcMalformedCurrency = 116,
+    RpcMalformedDirRoot = 117,
+    RpcMalformedDocumentID = 118,
+    RpcMalformedIssue = 119,
+    RpcMalformedIssuingChainDoor = 120,
+    RpcMalformedLockingChainDoor = 121,
+    RpcMalformedMPTIssuanceID = 122,
+    RpcMalformedMPTokenIssuance = 123,
+    RpcMalformedOwner = 124,
+    RpcMalformedSeq = 125,
+    RpcMalformedSponsee = 126,
+    RpcMalformedSponsor = 127,
+    RpcMalformedXChainOwnedClaimID = 128,
+    RpcMalformedXChainOwnedCreateAccountClaimID = 129,
+
+    // subscribe
+    RpcApiVersionConflict = 130,
+
+    // RpcLast should always equal the last code.
+    RpcLast = RpcApiVersionConflict,
 };
 
 /**
@@ -180,11 +232,6 @@ struct ErrorInfo
     {
     }
 
-    constexpr ErrorInfo(ErrorCodeI code, char const* token, char const* message)
-        : code(code), token(token), message(message), httpStatus(200)
-    {
-    }
-
     constexpr ErrorInfo(ErrorCodeI code, char const* token, char const* message, int httpStatus)
         : code(code), token(token), message(message), httpStatus(httpStatus)
     {
@@ -202,6 +249,18 @@ struct ErrorInfo
 ErrorInfo const&
 getErrorInfo(ErrorCodeI code);
 
+/**
+ * Returns the error code that owns @p token.
+ *
+ * A linear scan over views measured at compile time, run once per error reply.
+ * A duplicate token is a build error, so the answer is never ambiguous.
+ *
+ * @param token The error token to resolve.
+ * @return The code the table gives @p token, or RpcUnknown if no row names it.
+ */
+ErrorCodeI
+codeForToken(std::string_view token);
+
 /**
  * Add or update the json update to reflect the error code.
  */

include/xrpl/protocol/Fees.h

@@ -10,25 +10,6 @@ namespace xrpl {
 // This was the reference fee units used in the old fee calculation.
 inline constexpr std::uint32_t kFeeUnitsDeprecated = 10;
 
-// Number of micro-drops in one drop.
-inline constexpr std::uint32_t microDropsPerDrop{1'000'000};
-
-/**
- * Hard protocol bounds on the Feature Extension fee settings. A voted value
- * can never fall outside these, so `preflight`, which has no view, may bound
- * against them. Gas and bytecode limits are capped; gas price has a floor
- * (zero would make WASM execution effectively free).
- */
-inline constexpr std::uint32_t kMaxGasLimit{2'000'000};
-inline constexpr std::uint32_t kMaxBytecodeSizeLimit{200'000};
-inline constexpr std::uint32_t kMinGasPrice{1};
-
-// The following default values of fee settings will seed into FeeSettings
-// and write to the ledger on featureSmartEscrow activation.
-inline constexpr std::uint32_t kDefaultGasLimit{1'000'000};
-inline constexpr std::uint32_t kDefaultBytecodeSizeLimit{100'000};
-inline constexpr std::uint32_t kDefaultGasPrice{1'000'000};
-
 /**
  * Reflects the fee settings for a particular ledger.
  *
@@ -52,47 +33,13 @@ struct Fees
      */
     XRPAmount increment{0};
 
-    /**
-     * @brief Gas limit for Feature Extensions (instructions).
-     *
-     * This and the one below default to the protocol values rather than 0,
-     * because an explicit 0 is the voted kill switch.
-     */
-    std::uint32_t gasLimit{kDefaultGasLimit};
-
-    /**
-     * @brief Bytecode size limit for Feature Extensions (bytes).
-     */
-    std::uint32_t bytecodeSizeLimit{kDefaultBytecodeSizeLimit};
-
-    /**
-     * @brief Price of WASM gas (micro-drops).
-     */
-    std::uint32_t gasPrice{kDefaultGasPrice};
-
     explicit Fees() = default;
     Fees(Fees const&) = default;
     Fees&
     operator=(Fees const&) = default;
 
     Fees(XRPAmount base, XRPAmount reserve, XRPAmount increment)
-        : base{base}, reserve{reserve}, increment{increment}
-    {
-    }
-
-    Fees(
-        XRPAmount base,
-        XRPAmount reserve,
-        XRPAmount increment,
-        std::uint32_t gasLimit,
-        std::uint32_t bytecodeSizeLimit,
-        std::uint32_t gasPrice)
-        : base{base}
-        , reserve{reserve}
-        , increment{increment}
-        , gasLimit{gasLimit}
-        , bytecodeSizeLimit{bytecodeSizeLimit}
-        , gasPrice{gasPrice}
+        : base(base), reserve(reserve), increment(increment)
     {
     }
 

include/xrpl/protocol/Indexes.h

@@ -11,6 +11,7 @@
 #include <xrpl/protocol/Keylet.h>
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/STXChainBridge.h>
 #include <xrpl/protocol/SeqProxy.h>
 #include <xrpl/protocol/UintTypes.h>
 
@@ -320,6 +321,17 @@ amm(UInt256 const& amm) noexcept;
 Keylet
 delegate(AccountID const& account, AccountID const& authorizedAccount) noexcept;
 
+Keylet
+bridge(STXChainBridge const& bridge, STXChainBridge::ChainType chainType);
+
+// `seq` is stored as `sfXChainClaimID` in the object
+Keylet
+xChainClaimID(STXChainBridge const& bridge, std::uint64_t const seq);
+
+// `seq` is stored as `sfXChainAccountCreateCount` in the object
+Keylet
+xChainCreateAccountClaimID(STXChainBridge const& bridge, std::uint64_t const seq);
+
 Keylet
 did(AccountID const& account) noexcept;
 

include/xrpl/protocol/JsonRpc.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <xrpl/json/json_forwards.h>
+
+#include <string_view>
+
+namespace xrpl::rpc {
+
+/**
+ * Constants of the JSON-RPC 2.0 protocol itself.
+ *
+ * Kept apart from the `api_version` and `ripplerpc` constants in ApiVersion.h,
+ * which go when support for API versions 1 and 2 goes.
+ */
+
+/**
+ * Value of the `jsonrpc` member of a request and of its reply, fixed at "2.0"
+ * by the JSON-RPC specification.
+ */
+inline constexpr std::string_view kJsonRpcVersion{"2.0"};
+
+/**
+ * Codes for the `code` member of a JSON-RPC error object.
+ *
+ * The specification reserves -32768 to -32000 for the protocol and leaves
+ * -32000 to -32099 of it to the implementation.
+ *
+ * kJsonRpcServerError is the code for an error an XRPL handler reports. The
+ * XRPL token and code travel in the error's `data` member, so renumbering an
+ * XRPL error cannot change a JSON-RPC code.
+ *
+ * The codes from kJsonRpcServerOverloaded on lie outside the
+ * implementation-defined sub-range, which the specification does not allow.
+ * They are the codes every shipped version reports, so moving one breaks the
+ * clients matching on it.
+ */
+inline constexpr json::Int kJsonRpcServerError{-32000};
+inline constexpr json::Int kJsonRpcInvalidRequest{-32600};
+inline constexpr json::Int kJsonRpcMethodNotFound{-32601};
+inline constexpr json::Int kJsonRpcInvalidParams{-32602};
+inline constexpr json::Int kJsonRpcServerOverloaded{-32604};
+inline constexpr json::Int kJsonRpcForbidden{-32605};
+inline constexpr json::Int kJsonRpcWrongVersion{-32606};
+
+}  // namespace xrpl::rpc

include/xrpl/protocol/LedgerFormats.h

@@ -103,32 +103,6 @@ enum LedgerEntryType : std::uint16_t {
      */
     ltGENERATOR_MAP [[deprecated("This object type is not supported and should not be used.")]] =
         0x0067,
-
-    /**
-     * A deprecated type, removed with the XChainBridge amendment.
-     *
-     * @deprecated **This object type is not supported and should not be used.**
-     *             The XChainBridge amendment was never enabled on Mainnet.
-     */
-    ltBRIDGE [[deprecated("This object type is not supported and should not be used.")]] = 0x0069,
-
-    /**
-     * A deprecated type, removed with the XChainBridge amendment.
-     *
-     * @deprecated **This object type is not supported and should not be used.**
-     *             The XChainBridge amendment was never enabled on Mainnet.
-     */
-    ltXCHAIN_OWNED_CLAIM_ID
-    [[deprecated("This object type is not supported and should not be used.")]] = 0x0071,
-
-    /**
-     * A deprecated type, removed with the XChainBridge amendment.
-     *
-     * @deprecated **This object type is not supported and should not be used.**
-     *             The XChainBridge amendment was never enabled on Mainnet.
-     */
-    ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID
-    [[deprecated("This object type is not supported and should not be used.")]] = 0x0074,
 };
 
 /**

include/xrpl/protocol/Protocol.h

@@ -311,46 +311,24 @@ constexpr std::uint8_t kVaultStrategyFirstComeFirstServe = 1;
  * Default IOU scale factor for a Vault
  */
 constexpr std::uint8_t kVaultDefaultIouScale = 6;
-
 /**
- * Maximum Scale for a Vault created before featureLendingProtocolV1_2.
- * Chosen so 1 IOU can always convert to shares:
- * 10^19 > maxMPTokenAmount (2^64-1) > 10^18.
+ * Maximum scale factor for a Vault. The number is chosen to ensure that
+ * 1 IOU can be always converted to shares.
+ * 10^19 > maxMPTokenAmount (2^64-1) > 10^18
  */
-constexpr std::uint8_t kLegacyVaultMaximumIouScale = 18;
+constexpr std::uint8_t kVaultMaximumIouScale = 18;
 
 /**
- * Maximum Scale for a Vault created under featureLendingProtocolV1_2.
- */
-constexpr std::uint8_t kFixedPrecisionVaultMaximumIouScale = 10;
-
-/**
- * Vault ledger-entry schema versions, persisted as sfLEVersion.
- *
- * LEVersion records which protocol a Vault was created under so later
- * amendments can change the rules for new Vaults without rewriting
- * existing ones. VaultCreate writes it from the then-active lending
- * amendments; later transactions do not update it. A Vault created
- * under an older amendment keeps that amendment's behaviour for its
- * lifetime, even after a newer lending amendment activates.
- *
- * Absent sfLEVersion is implicit Legacy (version 0): instant interest
- * recognition and a dynamic AssetsTotal scale. CashBasis (V1.1) uses
- * cash-basis recognition on the same dynamic scale. FixedPrecision
- * (V1.2) keeps cash-basis recognition and adds the lifetime base grid.
+ * Vault ledger-entry schema versions. Assigned to newly created
+ * Vaults once featureLendingProtocolV1_1 is enabled. Vaults created before
+ * activation are left without LEVersion (implicit legacy version 0,
+ * instant interest recognition).
  */
 enum class VaultVersion : uint8_t {
     Legacy = 0,
     CashBasis,
-    FixedPrecision,
 };
 
-// Code compares VaultVersion values with < and >= (e.g. "CashBasis or later"),
-// so each later version must stay numerically larger than the one before.
-static_assert(
-    VaultVersion::Legacy < VaultVersion::CashBasis &&
-    VaultVersion::CashBasis < VaultVersion::FixedPrecision);
-
 /**
  * Vault kind. Distinguishes closed-ended vaults from the default open-ended
  * kind. Persisted as sfVaultKind (UINT8); absent means OpenEnded.
@@ -398,11 +376,6 @@ constexpr std::uint32_t kMaxInvestmentPeriod = std::chrono::seconds{std::chrono:
  */
 constexpr std::uint8_t kMaxAssetCheckDepth = 5;
 
-/**
- * Maximum length of a Data field in Escrow object that can be updated by WASM code.
- */
-constexpr std::size_t kMaxWasmDataLength = 1 * 1024;  // 1KB
-
 /**
  * A ledger index.
  */

include/xrpl/protocol/SField.h

@@ -31,6 +31,7 @@ class STBitString;
 template <class>
 class STInteger;
 class STNumber;
+class STXChainBridge;
 class STVector256;
 class STCurrency;
 
@@ -70,7 +71,7 @@ class STCurrency;
     STYPE(STI_UINT384, 22)                        \
     STYPE(STI_UINT512, 23)                        \
     STYPE(STI_ISSUE, 24)                          \
-    /* 25 is reserved */                          \
+    STYPE(STI_XCHAIN_BRIDGE, 25)                  \
     STYPE(STI_CURRENCY, 26)                       \
                                                   \
     /* high-level types */                        \
@@ -360,6 +361,7 @@ using SF_CURRENCY = TypedField<STCurrency>;
 using SF_NUMBER = TypedField<STNumber>;
 using SF_VL = TypedField<STBlob>;
 using SF_VECTOR256 = TypedField<STVector256>;
+using SF_XCHAIN_BRIDGE = TypedField<STXChainBridge>;
 // NOLINTEND(readability-identifier-naming)
 
 //------------------------------------------------------------------------------

include/xrpl/protocol/STAmount.h

@@ -696,16 +696,6 @@ divRound(STAmount const& v1, STAmount const& v2, Asset const& asset, bool roundU
 STAmount
 divRoundStrict(STAmount const& v1, STAmount const& v2, Asset const& asset, bool roundUp);
 
-/**
- * Returns amt * num / den, rounded in the requested direction.
- *
- * Dispatches to the XRPAmount, IOUAmount or MPTAmount overload. XRP and MPT
- * results are exact; an IOU result is rounded to the 16-digit mantissa in the
- * requested direction. Only Upward and Downward are supported.
- */
-[[nodiscard]] STAmount
-mulRatio(STAmount const& amt, std::uint32_t num, std::uint32_t den, Number::RoundingMode rounding);
-
 // Someone is offering X for Y, what is the rate?
 // Rate: smaller is better, the taker wants the most out: in/out
 // VFALCO TODO Return a Quality object
@@ -776,21 +766,6 @@ roundToAsset(
     return roundToScale(ret, scale);
 }
 
-/**
- * Check whether an arbitrary precision Number can be converted to an STAmount
- * of a given Asset without exceeding the asset's range.
- *
- * Use this before `roundToAsset` or `STAmount{asset, value}` on unchecked
- * input, since those throw for out-of-range values, e.g. XRP above
- * `STAmount::kMaxNativeN`.
- *
- * @param asset The relevant asset
- * @param value The value to be checked
- * @return true if the value is in range for the asset; false otherwise.
- */
-[[nodiscard]] bool
-isRepresentable(Asset const& asset, Number const& value);
-
 //------------------------------------------------------------------------------
 
 inline bool

include/xrpl/protocol/STObject.h

@@ -12,7 +12,6 @@
 #include <xrpl/protocol/HashPrefix.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/SOTemplate.h>
-#include <xrpl/protocol/STAccount.h>  // IWYU pragma: keep
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STBase.h>
 #include <xrpl/protocol/STBitString.h>

include/xrpl/protocol/STXChainBridge.h

@@ -0,0 +1,224 @@
+#pragma once
+
+#include <xrpl/basics/CountedObject.h>
+#include <xrpl/json/json_value.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Issue.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAccount.h>
+#include <xrpl/protocol/STBase.h>
+#include <xrpl/protocol/STIssue.h>
+#include <xrpl/protocol/Serializer.h>
+
+#include <cstddef>
+#include <memory>
+#include <string>
+#include <tuple>
+
+namespace xrpl {
+
+class Serializer;
+class STObject;
+
+class STXChainBridge final : public STBase, public CountedObject<STXChainBridge>
+{
+    STAccount lockingChainDoor_{sfLockingChainDoor};
+    STIssue lockingChainIssue_{sfLockingChainIssue};
+    STAccount issuingChainDoor_{sfIssuingChainDoor};
+    STIssue issuingChainIssue_{sfIssuingChainIssue};
+
+public:
+    using value_type = STXChainBridge;
+
+    enum class ChainType { Locking, Issuing };
+
+    static ChainType
+    otherChain(ChainType ct);
+
+    static ChainType
+    srcChain(bool wasLockingChainSend);
+
+    static ChainType
+    dstChain(bool wasLockingChainSend);
+
+    STXChainBridge();
+
+    explicit STXChainBridge(SField const& name);
+
+    STXChainBridge(STXChainBridge const& rhs) = default;
+
+    STXChainBridge(STObject const& o);
+
+    STXChainBridge(
+        AccountID const& srcChainDoor,
+        Issue const& srcChainIssue,
+        AccountID const& dstChainDoor,
+        Issue const& dstChainIssue);
+
+    explicit STXChainBridge(json::Value const& v);
+
+    explicit STXChainBridge(SField const& name, json::Value const& v);
+
+    explicit STXChainBridge(SerialIter& sit, SField const& name);
+
+    STXChainBridge&
+    operator=(STXChainBridge const& rhs) = default;
+
+    [[nodiscard]] std::string
+    getText() const override;
+
+    [[nodiscard]] STObject
+    toSTObject() const;
+
+    [[nodiscard]] AccountID const&
+    lockingChainDoor() const;
+
+    [[nodiscard]] Issue const&
+    lockingChainIssue() const;
+
+    [[nodiscard]] AccountID const&
+    issuingChainDoor() const;
+
+    [[nodiscard]] Issue const&
+    issuingChainIssue() const;
+
+    [[nodiscard]] AccountID const&
+    door(ChainType ct) const;
+
+    [[nodiscard]] Issue const&
+    issue(ChainType ct) const;
+
+    [[nodiscard]] SerializedTypeID
+    getSType() const override;
+
+    [[nodiscard]] json::Value getJson(JsonOptions) const override;
+
+    void
+    add(Serializer& s) const override;
+
+    [[nodiscard]] bool
+    isEquivalent(STBase const& t) const override;
+
+    [[nodiscard]] bool
+    isDefault() const override;
+
+    [[nodiscard]] value_type const&
+    value() const noexcept;
+
+private:
+    static std::unique_ptr<STXChainBridge>
+    construct(SerialIter&, SField const& name);
+
+    STBase*
+    copy(std::size_t n, void* buf) const override;
+    STBase*
+    move(std::size_t n, void* buf) override;
+
+    friend bool
+    operator==(STXChainBridge const& lhs, STXChainBridge const& rhs);
+
+    friend bool
+    operator<(STXChainBridge const& lhs, STXChainBridge const& rhs);
+};
+
+inline bool
+operator==(STXChainBridge const& lhs, STXChainBridge const& rhs)
+{
+    return std::tie(
+               lhs.lockingChainDoor_,
+               lhs.lockingChainIssue_,
+               lhs.issuingChainDoor_,
+               lhs.issuingChainIssue_) ==
+        std::tie(
+               rhs.lockingChainDoor_,
+               rhs.lockingChainIssue_,
+               rhs.issuingChainDoor_,
+               rhs.issuingChainIssue_);
+}
+
+inline bool
+operator<(STXChainBridge const& lhs, STXChainBridge const& rhs)
+{
+    return std::tie(
+               lhs.lockingChainDoor_,
+               lhs.lockingChainIssue_,
+               lhs.issuingChainDoor_,
+               lhs.issuingChainIssue_) <
+        std::tie(
+               rhs.lockingChainDoor_,
+               rhs.lockingChainIssue_,
+               rhs.issuingChainDoor_,
+               rhs.issuingChainIssue_);
+}
+
+inline AccountID const&
+STXChainBridge::lockingChainDoor() const
+{
+    return lockingChainDoor_.value();
+};
+
+inline Issue const&
+STXChainBridge::lockingChainIssue() const
+{
+    return lockingChainIssue_.value().get<Issue>();
+};
+
+inline AccountID const&
+STXChainBridge::issuingChainDoor() const
+{
+    return issuingChainDoor_.value();
+};
+
+inline Issue const&
+STXChainBridge::issuingChainIssue() const
+{
+    return issuingChainIssue_.value().get<Issue>();
+};
+
+inline STXChainBridge::value_type const&
+STXChainBridge::value() const noexcept
+{
+    return *this;
+}
+
+inline AccountID const&
+STXChainBridge::door(ChainType ct) const
+{
+    if (ct == ChainType::Locking)
+        return lockingChainDoor();
+    return issuingChainDoor();
+}
+
+inline Issue const&
+STXChainBridge::issue(ChainType ct) const
+{
+    if (ct == ChainType::Locking)
+        return lockingChainIssue();
+    return issuingChainIssue();
+}
+
+inline STXChainBridge::ChainType
+STXChainBridge::otherChain(ChainType ct)
+{
+    if (ct == ChainType::Locking)
+        return ChainType::Issuing;
+    return ChainType::Locking;
+}
+
+inline STXChainBridge::ChainType
+STXChainBridge::srcChain(bool wasLockingChainSend)
+{
+    if (wasLockingChainSend)
+        return ChainType::Locking;
+    return ChainType::Issuing;
+}
+
+inline STXChainBridge::ChainType
+STXChainBridge::dstChain(bool wasLockingChainSend)
+{
+    if (wasLockingChainSend)
+        return ChainType::Issuing;
+    return ChainType::Locking;
+}
+
+}  // namespace xrpl

include/xrpl/protocol/TER.h

@@ -133,6 +133,7 @@ enum TEMcodes : TERUnderlyingType {
     temBAD_MPT,
     temBAD_CIPHERTEXT,
     temINVALID_BYTECODE,
+    temTEMP_DISABLED,
 };
 
 //------------------------------------------------------------------------------
@@ -183,8 +184,6 @@ enum TEFcodes : TERUnderlyingType {
     tefBAD_PATH_COUNT,
     tefNO_BYTECODE,
     tefBYTECODE_NOT_INCLUDED,
-    tefTEMP_DISABLED,
-    tefEXCEEDS_LIMIT,
 };
 
 //------------------------------------------------------------------------------
@@ -232,8 +231,6 @@ enum TERcodes : TERUnderlyingType {
     terNO_DELEGATE_PERMISSION,  // Delegate does not have permission
     terLOCKED,                  // MPT is locked
     terNO_PERMISSION,           // No permission but retry
-    terTICKET_RESERVED,         // Ticket is reserved and cannot be consumed
-                                // until the reservation is released
 };
 
 //------------------------------------------------------------------------------

include/xrpl/protocol/TxFlags.h

@@ -189,6 +189,10 @@ inline constexpr FlagValue tfUniversalMask = ~tfUniversal;
         TF_FLAG(tfClawTwoAssets, 0x00000001),                                                                                                                  \
         MASK_ADJ(0))                                                                                                                                           \
                                                                                                                                                                \
+    TRANSACTION(XChainModifyBridge,                                                                                                                            \
+        TF_FLAG(tfClearAccountCreateAmount, 0x00010000),                                                                                                       \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
     TRANSACTION(VaultCreate,                                                                                                                                   \
         TF_FLAG(tfVaultPrivate, lsfVaultPrivate)                                                                                                               \
         TF_FLAG(tfVaultShareNonTransferable, 0x00020000),                                                                                                      \

include/xrpl/protocol/TxFormats.h

@@ -73,54 +73,6 @@ enum TxType : std::uint16_t
      * This transaction type installs a hook.
      */
     TtHookSet [[maybe_unused]] = 22,
-
-    /**
-     * This transaction type was removed with the XChainBridge amendment, which was never enabled
-     * on Mainnet. The value is reserved for historical purposes.
-     */
-    TtXChainCreateClaimID [[deprecated("This transaction type is not supported and should not be used.")]] = 41,
-
-    /**
-     * This transaction type was removed with the XChainBridge amendment, which was never enabled
-     * on Mainnet. The value is reserved for historical purposes.
-     */
-    TtXChainCommit [[deprecated("This transaction type is not supported and should not be used.")]] = 42,
-
-    /**
-     * This transaction type was removed with the XChainBridge amendment, which was never enabled
-     * on Mainnet. The value is reserved for historical purposes.
-     */
-    TtXChainClaim [[deprecated("This transaction type is not supported and should not be used.")]] = 43,
-
-    /**
-     * This transaction type was removed with the XChainBridge amendment, which was never enabled
-     * on Mainnet. The value is reserved for historical purposes.
-     */
-    TtXChainAccountCreateCommit [[deprecated("This transaction type is not supported and should not be used.")]] = 44,
-
-    /**
-     * This transaction type was removed with the XChainBridge amendment, which was never enabled
-     * on Mainnet. The value is reserved for historical purposes.
-     */
-    TtXChainAddClaimAttestation [[deprecated("This transaction type is not supported and should not be used.")]] = 45,
-
-    /**
-     * This transaction type was removed with the XChainBridge amendment, which was never enabled
-     * on Mainnet. The value is reserved for historical purposes.
-     */
-    TtXChainAddAccountCreateAttestation [[deprecated("This transaction type is not supported and should not be used.")]] = 46,
-
-    /**
-     * This transaction type was removed with the XChainBridge amendment, which was never enabled
-     * on Mainnet. The value is reserved for historical purposes.
-     */
-    TtXChainModifyBridge [[deprecated("This transaction type is not supported and should not be used.")]] = 47,
-
-    /**
-     * This transaction type was removed with the XChainBridge amendment, which was never enabled
-     * on Mainnet. The value is reserved for historical purposes.
-     */
-    TtXChainCreateBridge [[deprecated("This transaction type is not supported and should not be used.")]] = 48,
 };
 // clang-format on
 

include/xrpl/protocol/XChainAttestations.h

@@ -0,0 +1,471 @@
+#pragma once
+
+#include <xrpl/basics/Buffer.h>
+#include <xrpl/json/json_value.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STObject.h>
+#include <xrpl/protocol/STXChainBridge.h>
+#include <xrpl/protocol/SecretKey.h>
+
+#include <boost/container/flat_set.hpp>
+#include <boost/container/vector.hpp>
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace xrpl {
+
+namespace attestations {
+
+struct AttestationBase
+{
+    // Account associated with the public key
+    AccountID attestationSignerAccount;
+    // Public key from the witness server attesting to the event
+    PublicKey publicKey;
+    // Signature from the witness server attesting to the event
+    Buffer signature;
+    // Account on the sending chain that triggered the event (sent the
+    // transaction)
+    AccountID sendingAccount;
+    // Amount transferred on the sending chain
+    STAmount sendingAmount;
+    // Account on the destination chain that collects a share of the attestation
+    // reward
+    AccountID rewardAccount;
+    // Amount was transferred on the locking chain
+    bool wasLockingChainSend;
+
+    explicit AttestationBase(
+        AccountID attestationSignerAccount,
+        PublicKey const& publicKey,
+        Buffer signature,
+        AccountID const& sendingAccount,
+        STAmount sendingAmount,
+        AccountID const& rewardAccount,
+        bool wasLockingChainSend);
+
+    AttestationBase(AttestationBase const&) = default;
+
+    virtual ~AttestationBase() = default;
+
+    AttestationBase&
+    operator=(AttestationBase const&) = default;
+
+    // verify that the signature attests to the data.
+    [[nodiscard]] bool
+    verify(STXChainBridge const& bridge) const;
+
+protected:
+    explicit AttestationBase(STObject const& o);
+    explicit AttestationBase(json::Value const& v);
+
+    [[nodiscard]] static bool
+    equalHelper(AttestationBase const& lhs, AttestationBase const& rhs);
+
+    [[nodiscard]] static bool
+    sameEventHelper(AttestationBase const& lhs, AttestationBase const& rhs);
+
+    void
+    addHelper(STObject& o) const;
+
+private:
+    [[nodiscard]] virtual std::vector<std::uint8_t>
+    message(STXChainBridge const& bridge) const = 0;
+};
+
+// Attest to a regular cross-chain transfer
+struct AttestationClaim : AttestationBase
+{
+    std::uint64_t claimID;
+    std::optional<AccountID> dst;
+
+    explicit AttestationClaim(
+        AccountID attestationSignerAccount,
+        PublicKey const& publicKey,
+        Buffer signature,
+        AccountID const& sendingAccount,
+        STAmount const& sendingAmount,
+        AccountID const& rewardAccount,
+        bool wasLockingChainSend,
+        std::uint64_t claimId,
+        std::optional<AccountID> const& dst);
+
+    explicit AttestationClaim(
+        STXChainBridge const& bridge,
+        AccountID attestationSignerAccount,
+        PublicKey const& publicKey,
+        SecretKey const& secretKey,
+        AccountID const& sendingAccount,
+        STAmount const& sendingAmount,
+        AccountID const& rewardAccount,
+        bool wasLockingChainSend,
+        std::uint64_t claimId,
+        std::optional<AccountID> const& dst);
+
+    explicit AttestationClaim(STObject const& o);
+    explicit AttestationClaim(json::Value const& v);
+
+    [[nodiscard]] STObject
+    toSTObject() const;
+
+    // return true if the two attestations attest to the same thing
+    [[nodiscard]] bool
+    sameEvent(AttestationClaim const& rhs) const;
+
+    [[nodiscard]] static std::vector<std::uint8_t>
+    message(
+        STXChainBridge const& bridge,
+        AccountID const& sendingAccount,
+        STAmount const& sendingAmount,
+        AccountID const& rewardAccount,
+        bool wasLockingChainSend,
+        std::uint64_t claimID,
+        std::optional<AccountID> const& dst);
+
+    [[nodiscard]] bool
+    validAmounts() const;
+
+private:
+    [[nodiscard]] std::vector<std::uint8_t>
+    message(STXChainBridge const& bridge) const override;
+
+    friend bool
+    operator==(AttestationClaim const& lhs, AttestationClaim const& rhs);
+};
+
+struct CmpByClaimID
+{
+    bool
+    operator()(AttestationClaim const& lhs, AttestationClaim const& rhs) const
+    {
+        return lhs.claimID < rhs.claimID;
+    }
+};
+
+// Attest to a cross-chain transfer that creates an account
+struct AttestationCreateAccount : AttestationBase
+{
+    // createCount on the sending chain. This is the value of the `CreateCount`
+    // field of the bridge on the sending chain when the transaction was
+    // executed.
+    std::uint64_t createCount;
+    // Account to create on the destination chain
+    AccountID toCreate;
+    // Total amount of the reward pool
+    STAmount rewardAmount;
+
+    explicit AttestationCreateAccount(STObject const& o);
+
+    explicit AttestationCreateAccount(json::Value const& v);
+
+    explicit AttestationCreateAccount(
+        AccountID attestationSignerAccount,
+        PublicKey const& publicKey,
+        Buffer signature,
+        AccountID const& sendingAccount,
+        STAmount const& sendingAmount,
+        STAmount rewardAmount,
+        AccountID const& rewardAccount,
+        bool wasLockingChainSend,
+        std::uint64_t createCount,
+        AccountID const& toCreate);
+
+    explicit AttestationCreateAccount(
+        STXChainBridge const& bridge,
+        AccountID attestationSignerAccount,
+        PublicKey const& publicKey,
+        SecretKey const& secretKey,
+        AccountID const& sendingAccount,
+        STAmount const& sendingAmount,
+        STAmount const& rewardAmount,
+        AccountID const& rewardAccount,
+        bool wasLockingChainSend,
+        std::uint64_t createCount,
+        AccountID const& toCreate);
+
+    [[nodiscard]] STObject
+    toSTObject() const;
+
+    // return true if the two attestations attest to the same thing
+    [[nodiscard]] bool
+    sameEvent(AttestationCreateAccount const& rhs) const;
+
+    friend bool
+    operator==(AttestationCreateAccount const& lhs, AttestationCreateAccount const& rhs);
+
+    [[nodiscard]] static std::vector<std::uint8_t>
+    message(
+        STXChainBridge const& bridge,
+        AccountID const& sendingAccount,
+        STAmount const& sendingAmount,
+        STAmount const& rewardAmount,
+        AccountID const& rewardAccount,
+        bool wasLockingChainSend,
+        std::uint64_t createCount,
+        AccountID const& dst);
+
+    [[nodiscard]] bool
+    validAmounts() const;
+
+private:
+    [[nodiscard]] std::vector<std::uint8_t>
+    message(STXChainBridge const& bridge) const override;
+};
+
+struct CmpByCreateCount
+{
+    bool
+    operator()(AttestationCreateAccount const& lhs, AttestationCreateAccount const& rhs) const
+    {
+        return lhs.createCount < rhs.createCount;
+    }
+};
+
+};  // namespace attestations
+
+// Result when checking when two attestation match.
+enum class AttestationMatch {
+    // One of the fields doesn't match, and it isn't the dst field
+    NonDstMismatch,
+    // all of the fields match, except the dst field
+    MatchExceptDst,
+    // all of the fields match
+    Match,
+};
+
+struct XChainClaimAttestation
+{
+    using TSignedAttestation = attestations::AttestationClaim;
+    static SField const& arrayFieldName;
+
+    AccountID keyAccount;
+    PublicKey publicKey;
+    STAmount amount;
+    AccountID rewardAccount;
+    bool wasLockingChainSend;
+    std::optional<AccountID> dst;
+
+    struct MatchFields
+    {
+        STAmount amount;
+        bool wasLockingChainSend;
+        std::optional<AccountID> dst;
+        MatchFields(TSignedAttestation const& att);
+        MatchFields(STAmount a, bool b, std::optional<AccountID> const& d)
+            : amount{std::move(a)}, wasLockingChainSend{b}, dst{d}
+        {
+        }
+    };
+
+    explicit XChainClaimAttestation(
+        AccountID const& keyAccount,
+        PublicKey const& publicKey,
+        STAmount const& amount,
+        AccountID const& rewardAccount,
+        bool wasLockingChainSend,
+        std::optional<AccountID> const& dst);
+
+    explicit XChainClaimAttestation(
+        STAccount const& keyAccount,
+        PublicKey const& publicKey,
+        STAmount const& amount,
+        STAccount const& rewardAccount,
+        bool wasLockingChainSend,
+        std::optional<STAccount> const& dst);
+
+    explicit XChainClaimAttestation(TSignedAttestation const& claimAtt);
+
+    explicit XChainClaimAttestation(STObject const& o);
+
+    explicit XChainClaimAttestation(json::Value const& v);
+
+    [[nodiscard]] AttestationMatch
+    match(MatchFields const& rhs) const;
+
+    [[nodiscard]] STObject
+    toSTObject() const;
+
+    friend bool
+    operator==(XChainClaimAttestation const& lhs, XChainClaimAttestation const& rhs);
+};
+
+struct XChainCreateAccountAttestation
+{
+    using TSignedAttestation = attestations::AttestationCreateAccount;
+    static SField const& arrayFieldName;
+
+    AccountID keyAccount;
+    PublicKey publicKey;
+    STAmount amount;
+    STAmount rewardAmount;
+    AccountID rewardAccount;
+    bool wasLockingChainSend;
+    AccountID dst;
+
+    struct MatchFields
+    {
+        STAmount amount;
+        STAmount rewardAmount;
+        bool wasLockingChainSend;
+        AccountID dst;
+
+        MatchFields(TSignedAttestation const& att);
+    };
+
+    explicit XChainCreateAccountAttestation(
+        AccountID const& keyAccount,
+        PublicKey const& publicKey,
+        STAmount const& amount,
+        STAmount const& rewardAmount,
+        AccountID const& rewardAccount,
+        bool wasLockingChainSend,
+        AccountID const& dst);
+
+    explicit XChainCreateAccountAttestation(TSignedAttestation const& claimAtt);
+
+    explicit XChainCreateAccountAttestation(STObject const& o);
+
+    explicit XChainCreateAccountAttestation(json::Value const& v);
+
+    [[nodiscard]] STObject
+    toSTObject() const;
+
+    [[nodiscard]] AttestationMatch
+    match(MatchFields const& rhs) const;
+
+    friend bool
+    operator==(
+        XChainCreateAccountAttestation const& lhs,
+        XChainCreateAccountAttestation const& rhs);
+};
+
+// Attestations from witness servers for a particular claim ID and bridge.
+// Only one attestation per signature is allowed.
+template <class TAttestation>
+class XChainAttestationsBase
+{
+public:
+    using AttCollection = std::vector<TAttestation>;
+
+private:
+    // Set a max number of allowed attestations to limit the amount of memory
+    // allocated and processing time. This number is much larger than the actual
+    // number of attestation a server would ever expect.
+    static constexpr std::uint32_t kMaxAttestations = 256;
+    AttCollection attestations_;
+
+protected:
+    // Prevent slicing to the base class
+    ~XChainAttestationsBase() = default;
+
+public:
+    XChainAttestationsBase() = default;
+    XChainAttestationsBase(XChainAttestationsBase const& rhs) = default;
+    XChainAttestationsBase&
+    operator=(XChainAttestationsBase const& rhs) = default;
+
+    explicit XChainAttestationsBase(AttCollection&& sigs);
+
+    explicit XChainAttestationsBase(json::Value const& v);
+
+    explicit XChainAttestationsBase(STArray const& arr);
+
+    [[nodiscard]] STArray
+    toSTArray() const;
+
+    [[nodiscard]] AttCollection::const_iterator
+    begin() const;
+
+    [[nodiscard]] AttCollection::const_iterator
+    end() const;
+
+    AttCollection::iterator
+    begin();
+
+    AttCollection::iterator
+    end();
+
+    template <class F>
+    std::size_t
+    eraseIf(F&& f);
+
+    [[nodiscard]] std::size_t
+    size() const;
+
+    [[nodiscard]] bool
+    empty() const;
+
+    [[nodiscard]] AttCollection const&
+    attestations() const;
+
+    template <class T>
+    void
+    emplaceBack(T&& att);
+};
+
+template <class TAttestation>
+[[nodiscard]] inline bool
+operator==(
+    XChainAttestationsBase<TAttestation> const& lhs,
+    XChainAttestationsBase<TAttestation> const& rhs)
+{
+    return lhs.attestations() == rhs.attestations();
+}
+
+template <class TAttestation>
+inline XChainAttestationsBase<TAttestation>::AttCollection const&
+XChainAttestationsBase<TAttestation>::attestations() const
+{
+    return attestations_;
+};
+
+template <class TAttestation>
+template <class T>
+inline void
+XChainAttestationsBase<TAttestation>::emplaceBack(T&& att)
+{
+    attestations_.emplace_back(std::forward<T>(att));
+};
+
+template <class TAttestation>
+template <class F>
+inline std::size_t
+XChainAttestationsBase<TAttestation>::eraseIf(F&& f)
+{
+    return std::erase_if(attestations_, std::forward<F>(f));
+}
+
+template <class TAttestation>
+inline std::size_t
+XChainAttestationsBase<TAttestation>::size() const
+{
+    return attestations_.size();
+}
+
+template <class TAttestation>
+inline bool
+XChainAttestationsBase<TAttestation>::empty() const
+{
+    return attestations_.empty();
+}
+
+class XChainClaimAttestations final : public XChainAttestationsBase<XChainClaimAttestation>
+{
+    using TBase = XChainAttestationsBase<XChainClaimAttestation>;
+    using TBase::TBase;
+};
+
+class XChainCreateAccountAttestations final
+    : public XChainAttestationsBase<XChainCreateAccountAttestation>
+{
+    using TBase = XChainAttestationsBase<XChainCreateAccountAttestation>;
+    using TBase::TBase;
+};
+
+}  // namespace xrpl

include/xrpl/protocol/XRPAmount.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <xrpl/basics/MathUtilities.h>
 #include <xrpl/basics/Number.h>
 #include <xrpl/basics/contract.h>
 #include <xrpl/beast/utility/Zero.h>
@@ -70,13 +69,7 @@ public:
     constexpr XRPAmount
     operator*(value_type const& rhs) const
     {
-        if (auto const result = checkedMul(drops_, rhs))
-            return XRPAmount{*result};
-        // Not reached in constant evaluation: an overflowing constant
-        // expression fails to compile instead.
-        XRPAmount product{*this};
-        product *= rhs;
-        return product;
+        return XRPAmount{drops_ * rhs};
     }
 
     friend constexpr XRPAmount
@@ -89,23 +82,37 @@ public:
     XRPAmount&
     operator+=(XRPAmount const& other)
     {
-        return *this += other.drops();
+        drops_ += other.drops();
+        return *this;
     }
 
     XRPAmount&
     operator-=(XRPAmount const& other)
     {
-        return *this -= other.drops();
+        drops_ -= other.drops();
+        return *this;
     }
 
     XRPAmount&
-    operator+=(value_type const& rhs);
+    operator+=(value_type const& rhs)
+    {
+        drops_ += rhs;
+        return *this;
+    }
 
     XRPAmount&
-    operator-=(value_type const& rhs);
+    operator-=(value_type const& rhs)
+    {
+        drops_ -= rhs;
+        return *this;
+    }
 
     XRPAmount&
-    operator*=(value_type const& rhs);
+    operator*=(value_type const& rhs)
+    {
+        drops_ *= rhs;
+        return *this;
+    }
 
     XRPAmount
     operator-() const

include/xrpl/protocol/detail/features.macro

@@ -17,7 +17,6 @@
 
 XRPL_FEATURE(Cosign,                      Supported::No,  VoteBehavior::DefaultNo)
 XRPL_FEATURE(SmartEscrow,                 Supported::No,  VoteBehavior::DefaultNo)
-// Requires LendingProtocolV1_1. New vaults take FixedPrecision plus cash-basis.
 XRPL_FEATURE(LendingProtocolV1_2,         Supported::No,  VoteBehavior::DefaultNo)
 XRPL_FIX    (Cleanup3_5_0,                Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(ConfidentialMPTKeyRotation,  Supported::No,  VoteBehavior::DefaultNo)
@@ -61,10 +60,14 @@ XRPL_FIX    (InnerObjTemplate2,          Supported::Yes, VoteBehavior::DefaultNo
 XRPL_FIX    (EnforceNFTokenTrustline,    Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (ReducedOffersV2,            Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(NFTokenMintOffer,           Supported::Yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (AMMv1_1,                    Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (PreviousTxnID,              Supported::Yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (XChainRewardRounding,       Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (EmptyDID,                   Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(PriceOracle,                Supported::Yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (FillOrKill,                 Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(DID,                        Supported::Yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(XChainBridge,               Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(AMM,                        Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(XRPFees,                    Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (RemoveNFTokenAutoTrustLine, Supported::Yes, VoteBehavior::DefaultYes)
@@ -82,9 +85,6 @@ XRPL_FIX    (RemoveNFTokenAutoTrustLine, Supported::Yes, VoteBehavior::DefaultYe
 // to vote for it, the feature can be removed entirely from the code. Until
 // then the feature needs to be marked explicitly as obsolete, e.g.
 // XRPL_FEATURE(Example, Supported::yes, VoteBehavior::Obsolete)
-XRPL_FEATURE(XChainBridge,               Supported::Yes, VoteBehavior::Obsolete)
-XRPL_FIX    (XChainRewardRounding,       Supported::Yes, VoteBehavior::Obsolete)
-
 // The following amendments have been active for at least two years. Their
 // pre-amendment code has been removed and the identifiers are deprecated.
 // All known amendments and amendments that may appear in a validated ledger
@@ -106,10 +106,8 @@ XRPL_RETIRE_FIX(1623)
 XRPL_RETIRE_FIX(1781)
 XRPL_RETIRE_FIX(AmendmentMajorityCalc)
 XRPL_RETIRE_FIX(AMMOverflowOffer)
-XRPL_RETIRE_FIX(AMMv1_1)
 XRPL_RETIRE_FIX(CheckThreading)
 XRPL_RETIRE_FIX(DisallowIncomingV1)
-XRPL_RETIRE_FIX(FillOrKill)
 XRPL_RETIRE_FIX(InnerObjTemplate)
 XRPL_RETIRE_FIX(MasterKeyAsRegularKey)
 XRPL_RETIRE_FIX(NonFungibleTokensV1_2)

include/xrpl/protocol/detail/ledger_entries.macro

@@ -206,6 +206,23 @@ LEDGER_ENTRY(ltLEDGER_HASHES, 0x0068, LedgerHashes, hashes, ({
     {sfHashes,               SoeRequired},
 }))
 
+/** The ledger object which lists details about sidechains.
+
+    \sa keylet::bridge
+*/
+LEDGER_ENTRY(ltBRIDGE, 0x0069, Bridge, bridge, ({
+    {sfAccount,                  SoeRequired},
+    {sfSignatureReward,          SoeRequired},
+    {sfMinAccountCreateAmount,   SoeOptional},
+    {sfXChainBridge,             SoeRequired},
+    {sfXChainClaimID,            SoeRequired},
+    {sfXChainAccountCreateCount, SoeRequired},
+    {sfXChainAccountClaimCount,  SoeRequired},
+    {sfOwnerNode,                SoeRequired},
+    {sfPreviousTxnID,            SoeRequired},
+    {sfPreviousTxnLgrSeq,        SoeRequired},
+}))
+
 /** A ledger object which describes an offer on the DEX.
 
     \sa keylet::offer
@@ -238,6 +255,22 @@ LEDGER_ENTRY_DUPLICATE(ltDEPOSIT_PREAUTH, 0x0070, DepositPreauth, deposit_preaut
     {sfAuthorizeCredentials, SoeOptional},
 }))
 
+/** A claim id for a cross chain transaction.
+
+    \sa keylet::xChainClaimID
+*/
+LEDGER_ENTRY(ltXCHAIN_OWNED_CLAIM_ID, 0x0071, XChainOwnedClaimID, xchain_owned_claim_id, ({
+    {sfAccount,                 SoeRequired},
+    {sfXChainBridge,            SoeRequired},
+    {sfXChainClaimID,           SoeRequired},
+    {sfOtherChainSource,        SoeRequired},
+    {sfXChainClaimAttestations, SoeRequired},
+    {sfSignatureReward,         SoeRequired},
+    {sfOwnerNode,               SoeRequired},
+    {sfPreviousTxnID,           SoeRequired},
+    {sfPreviousTxnLgrSeq,       SoeRequired},
+}))
+
 /** A ledger object which describes a bidirectional trust line.
 
     @note Per Vinnie Falco this should be renamed to ltTRUST_LINE
@@ -285,6 +318,20 @@ LEDGER_ENTRY(ltFEE_SETTINGS, 0x0073, FeeSettings, fee, ({
     {sfPreviousTxnLgrSeq,      SoeOptional},
 }))
 
+/** A claim id for a cross chain create account transaction.
+
+    \sa keylet::xChainCreateAccountClaimID
+*/
+LEDGER_ENTRY(ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID, 0x0074, XChainOwnedCreateAccountClaimID, xchain_owned_create_account_claim_id, ({
+    {sfAccount,                         SoeRequired},
+    {sfXChainBridge,                    SoeRequired},
+    {sfXChainAccountCreateCount,        SoeRequired},
+    {sfXChainCreateAccountAttestations, SoeRequired},
+    {sfOwnerNode,                       SoeRequired},
+    {sfPreviousTxnID,                   SoeRequired},
+    {sfPreviousTxnLgrSeq,               SoeRequired},
+}))
+
 /** A ledger object describing a single escrow.
 
     \sa keylet::escrow
@@ -370,7 +417,6 @@ LEDGER_ENTRY(ltMPTOKEN_ISSUANCE, 0x007e, MPTokenIssuance, mpt_issuance, ({
     {sfAuditorEncryptionKey,     SoeOptional},
     {sfIssuerKeyEpoch,           SoeOptional},
     {sfAuditorKeyEpoch,          SoeOptional},
-    {sfInitialIssuerEncryptionKey, SoeOptional},
     {sfConfidentialOutstandingAmount, SoeDefault},
 }))
 
@@ -392,7 +438,6 @@ LEDGER_ENTRY(ltMPTOKEN, 0x007f, MPToken, mptoken, ({
     {sfAuditorEncryptedBalance,     SoeOptional},
     {sfIssuerKeyMirrorEpoch,        SoeOptional},
     {sfAuditorKeyMirrorEpoch,       SoeOptional},
-    {sfIssuerMirrorEncryptionKey,   SoeOptional},
     {sfHolderEncryptionKey,         SoeOptional},
     {sfRecoveryKey,                 SoeOptional},
 }))
@@ -469,8 +514,6 @@ LEDGER_ENTRY(ltVAULT, 0x0084, Vault, vault, ({
     {sfAssetsAvailable,      SoeDefault},
     {sfAssetsMaximum,        SoeDefault},
     {sfLossUnrealized,       SoeDefault},
-    {sfYieldUnrealized,      SoeDefault},
-    {sfAssetsDeployed,       SoeDefault},
     {sfShareMPTID,           SoeRequired},
     {sfWithdrawalPolicy,     SoeRequired},
     {sfScale,                SoeDefault},

include/xrpl/protocol/detail/sfields.macro

@@ -5,9 +5,6 @@
 #error "undefined macro: TYPED_SFIELD"
 #endif
 
-// A code marked "reserved" is not assigned to a field. Do not reuse a reserved
-// code until a year or two after its field was removed, so that no supported
-// release or tool still knows the old meaning.
 
 // untyped
 UNTYPED_SFIELD(sfLedgerEntry,            LEDGERENTRY, 257)
@@ -26,7 +23,8 @@ TYPED_SFIELD(sfLEVersion,                UINT8,      6)
 // 8-bit integers (uncommon)
 TYPED_SFIELD(sfTickSize,                 UINT8,     16)
 TYPED_SFIELD(sfUNLModifyDisabling,       UINT8,     17)
-// 18 to 19 reserved
+// 18 unused
+TYPED_SFIELD(sfWasLockingChainSend,      UINT8,     19)
 TYPED_SFIELD(sfWithdrawalPolicy,         UINT8,     20)
 TYPED_SFIELD(sfContractResult,           UINT8,     21)
 TYPED_SFIELD(sfVaultKind,                UINT8,     22)
@@ -41,7 +39,7 @@ TYPED_SFIELD(sfDiscountedFee,            UINT16,     6)
 
 // 16-bit integers (uncommon)
 TYPED_SFIELD(sfVersion,                  UINT16,    16)
-// 17 to 20 reserved
+// 17 to 20 unused
 TYPED_SFIELD(sfLedgerFixType,            UINT16,    21)
 TYPED_SFIELD(sfManagementFeeRate,        UINT16,    22) // 1/10 basis points (bips)
 
@@ -92,7 +90,7 @@ TYPED_SFIELD(sfTicketSequence,           UINT32,    41)
 TYPED_SFIELD(sfNFTokenTaxon,             UINT32,    42)
 TYPED_SFIELD(sfMintedNFTokens,           UINT32,    43)
 TYPED_SFIELD(sfBurnedNFTokens,           UINT32,    44)
-// 45 to 47 reserved
+// 45 to 47 unused
 TYPED_SFIELD(sfVoteWeight,               UINT32,    48)
 TYPED_SFIELD(sfFirstNFTokenSequence,     UINT32,    50)
 TYPED_SFIELD(sfOracleDocumentID,         UINT32,    51)
@@ -147,9 +145,11 @@ TYPED_SFIELD(sfNFTokenOfferNode,         UINT64,    12)
 TYPED_SFIELD(sfEmitBurden,               UINT64,    13)
 
 // 64-bit integers (uncommon)
-// 16 to 18 reserved
+// 16 to 18 unused
 TYPED_SFIELD(sfReferenceCount,           UINT64,    19)
-// 20 to 22 reserved
+TYPED_SFIELD(sfXChainClaimID,            UINT64,    20)
+TYPED_SFIELD(sfXChainAccountCreateCount, UINT64,    21)
+TYPED_SFIELD(sfXChainAccountClaimCount,  UINT64,    22)
 TYPED_SFIELD(sfAssetPrice,               UINT64,    23)
 TYPED_SFIELD(sfMaximumAmount,            UINT64,    24, SField::kSmdBaseTen|SField::kSmdDefault)
 TYPED_SFIELD(sfOutstandingAmount,        UINT64,    25, SField::kSmdBaseTen|SField::kSmdDefault)
@@ -199,7 +199,7 @@ TYPED_SFIELD(sfBookDirectory,            UINT256,   16)
 TYPED_SFIELD(sfInvoiceID,                UINT256,   17)
 TYPED_SFIELD(sfNickname,                 UINT256,   18)
 TYPED_SFIELD(sfAmendment,                UINT256,   19)
-//                                                  20 reserved
+//                                                  20 unused
 TYPED_SFIELD(sfDigest,                   UINT256,   21)
 TYPED_SFIELD(sfChannel,                  UINT256,   22)
 TYPED_SFIELD(sfConsensusHash,            UINT256,   23)
@@ -209,7 +209,7 @@ TYPED_SFIELD(sfPreviousPageMin,          UINT256,   26)
 TYPED_SFIELD(sfNextPageMin,              UINT256,   27)
 TYPED_SFIELD(sfNFTokenBuyOffer,          UINT256,   28)
 TYPED_SFIELD(sfNFTokenSellOffer,         UINT256,   29)
-// 30 to 33 reserved
+// 30 to 33 unused
 TYPED_SFIELD(sfDomainID,                 UINT256,   34)
 TYPED_SFIELD(sfVaultID,                  UINT256,   35,
     SField::kSmdPseudoAccount | SField::kSmdDefault)
@@ -240,8 +240,6 @@ TYPED_SFIELD(sfPrincipalRequested,       NUMBER,     14)
 TYPED_SFIELD(sfTotalValueOutstanding,    NUMBER,     15, SField::kSmdNeedsAsset | SField::kSmdDefault)
 TYPED_SFIELD(sfPeriodicPayment,          NUMBER,     16)
 TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17, SField::kSmdNeedsAsset | SField::kSmdDefault)
-TYPED_SFIELD(sfYieldUnrealized,          NUMBER,     18, SField::kSmdNeedsAsset | SField::kSmdDefault)
-TYPED_SFIELD(sfAssetsDeployed,           NUMBER,     19, SField::kSmdNeedsAsset | SField::kSmdDefault)
 
 // 32-bit signed (common)
 TYPED_SFIELD(sfLoanScale,                INT32,      1)
@@ -268,7 +266,7 @@ TYPED_SFIELD(sfMinimumOffer,             AMOUNT,    16)
 TYPED_SFIELD(sfRippleEscrow,             AMOUNT,    17)
 TYPED_SFIELD(sfDeliveredAmount,          AMOUNT,    18)
 TYPED_SFIELD(sfNFTokenBrokerFee,         AMOUNT,    19)
-// 20 to 21 reserved
+// 20 to 21 unused
 // currency amount (fees)
 TYPED_SFIELD(sfBaseFeeDrops,             AMOUNT,    22)
 TYPED_SFIELD(sfReserveBaseDrops,         AMOUNT,    23)
@@ -279,7 +277,8 @@ TYPED_SFIELD(sfLPTokenOut,               AMOUNT,    25)
 TYPED_SFIELD(sfLPTokenIn,                AMOUNT,    26)
 TYPED_SFIELD(sfEPrice,                   AMOUNT,    27)
 TYPED_SFIELD(sfPrice,                    AMOUNT,    28)
-// 29 to 30 reserved
+TYPED_SFIELD(sfSignatureReward,          AMOUNT,    29)
+TYPED_SFIELD(sfMinAccountCreateAmount,   AMOUNT,    30)
 TYPED_SFIELD(sfLPTokenBalance,           AMOUNT,    31)
 TYPED_SFIELD(sfFeeAmount,                AMOUNT,    32)
 TYPED_SFIELD(sfMaxFee,                   AMOUNT,    33)
@@ -308,7 +307,7 @@ TYPED_SFIELD(sfMasterSignature,          VL,        18, SField::kSmdDefault, SFi
 TYPED_SFIELD(sfUNLModifyValidator,       VL,        19)
 TYPED_SFIELD(sfValidatorToDisable,       VL,        20)
 TYPED_SFIELD(sfValidatorToReEnable,      VL,        21)
-// 22 to 25 reserved
+// 22 to 25 unused
 TYPED_SFIELD(sfDIDDocument,              VL,        26)
 TYPED_SFIELD(sfData,                     VL,        27)
 TYPED_SFIELD(sfAssetClass,               VL,        28)
@@ -332,8 +331,6 @@ TYPED_SFIELD(sfAmountCommitment,            VL,     45)
 TYPED_SFIELD(sfBalanceCommitment,           VL,     46)
 TYPED_SFIELD(sfBytecode,                    VL,     47)
 TYPED_SFIELD(sfRecoveryKey,                 VL,     48)
-TYPED_SFIELD(sfInitialIssuerEncryptionKey,  VL,     49)
-TYPED_SFIELD(sfIssuerMirrorEncryptionKey,   VL,     50)
 
 // account (common)
 TYPED_SFIELD(sfAccount,                  ACCOUNT,    1)
@@ -342,7 +339,7 @@ TYPED_SFIELD(sfDestination,              ACCOUNT,    3)
 TYPED_SFIELD(sfIssuer,                   ACCOUNT,    4)
 TYPED_SFIELD(sfAuthorize,                ACCOUNT,    5)
 TYPED_SFIELD(sfUnauthorize,              ACCOUNT,    6)
-//                                                   7 reserved
+//                                                   7 unused
 TYPED_SFIELD(sfRegularKey,               ACCOUNT,    8)
 TYPED_SFIELD(sfNFTokenMinter,            ACCOUNT,    9)
 TYPED_SFIELD(sfEmitCallback,             ACCOUNT,   10)
@@ -350,7 +347,13 @@ TYPED_SFIELD(sfHolder,                   ACCOUNT,   11)
 TYPED_SFIELD(sfDelegate,                 ACCOUNT,   12)
 
 // account (uncommon)
-// 16 to 23 reserved
+// 16 unused
+TYPED_SFIELD(sfOtherChainSource,         ACCOUNT,   18)
+TYPED_SFIELD(sfOtherChainDestination,    ACCOUNT,   19)
+TYPED_SFIELD(sfAttestationSignerAccount, ACCOUNT,   20)
+TYPED_SFIELD(sfAttestationRewardAccount, ACCOUNT,   21)
+TYPED_SFIELD(sfLockingChainDoor,         ACCOUNT,   22)
+TYPED_SFIELD(sfIssuingChainDoor,         ACCOUNT,   23)
 TYPED_SFIELD(sfSubject,                  ACCOUNT,   24)
 TYPED_SFIELD(sfBorrower,                 ACCOUNT,   25)
 TYPED_SFIELD(sfCounterparty,             ACCOUNT,   26)
@@ -376,10 +379,14 @@ TYPED_SFIELD(sfBaseAsset,                CURRENCY,   1)
 TYPED_SFIELD(sfQuoteAsset,               CURRENCY,   2)
 
 // issue
-// 1 to 2 reserved
+TYPED_SFIELD(sfLockingChainIssue,        ISSUE,      1)
+TYPED_SFIELD(sfIssuingChainIssue,        ISSUE,      2)
 TYPED_SFIELD(sfAsset,                    ISSUE,      3)
 TYPED_SFIELD(sfAsset2,                   ISSUE,      4)
 
+// bridge
+TYPED_SFIELD(sfXChainBridge,             XCHAIN_BRIDGE, 1)
+
 // inner object
 // OBJECT/1 is reserved for end of object
 UNTYPED_SFIELD(sfTransactionMetaData,    OBJECT,     2)
@@ -394,19 +401,22 @@ UNTYPED_SFIELD(sfMemo,                   OBJECT,    10)
 UNTYPED_SFIELD(sfSignerEntry,            OBJECT,    11)
 UNTYPED_SFIELD(sfNFToken,                OBJECT,    12)
 UNTYPED_SFIELD(sfEmitDetails,            OBJECT,    13)
-// 14 reserved
+// 14 unused
 UNTYPED_SFIELD(sfPermission,             OBJECT,    15)
 
 // inner object (uncommon)
 UNTYPED_SFIELD(sfSigner,                 OBJECT,    16)
-//                                                  17 reserved
+//                                                  17 unused
 UNTYPED_SFIELD(sfMajority,               OBJECT,    18)
 UNTYPED_SFIELD(sfDisabledValidator,      OBJECT,    19)
-// 20 to 24 reserved
+// 20 to 24 unused
 UNTYPED_SFIELD(sfVoteEntry,              OBJECT,    25)
 UNTYPED_SFIELD(sfAuctionSlot,            OBJECT,    26)
 UNTYPED_SFIELD(sfAuthAccount,            OBJECT,    27)
-// 28 to 31 reserved
+UNTYPED_SFIELD(sfXChainClaimProofSig,    OBJECT,    28)
+UNTYPED_SFIELD(sfXChainCreateAccountProofSig, OBJECT, 29)
+UNTYPED_SFIELD(sfXChainClaimAttestationCollectionElement, OBJECT, 30)
+UNTYPED_SFIELD(sfXChainCreateAccountAttestationCollectionElement, OBJECT, 31)
 UNTYPED_SFIELD(sfPriceData,              OBJECT,    32)
 UNTYPED_SFIELD(sfCredential,             OBJECT,    33)
 UNTYPED_SFIELD(sfRawTransaction,         OBJECT,    34)
@@ -428,14 +438,17 @@ UNTYPED_SFIELD(sfSufficient,             ARRAY,      7)
 UNTYPED_SFIELD(sfAffectedNodes,          ARRAY,      8)
 UNTYPED_SFIELD(sfMemos,                  ARRAY,      9)
 UNTYPED_SFIELD(sfNFTokens,               ARRAY,     10)
-// 11 reserved
+// 11 unused
 UNTYPED_SFIELD(sfVoteSlots,              ARRAY,     12)
 UNTYPED_SFIELD(sfAdditionalBooks,        ARRAY,     13)
 
 // array of objects (uncommon)
 UNTYPED_SFIELD(sfMajorities,             ARRAY,     16)
 UNTYPED_SFIELD(sfDisabledValidators,     ARRAY,     17)
-// 18 to 23 reserved
+// 18 to 20 unused
+UNTYPED_SFIELD(sfXChainClaimAttestations, ARRAY,    21)
+UNTYPED_SFIELD(sfXChainCreateAccountAttestations, ARRAY, 22)
+//                                                  23 unused
 UNTYPED_SFIELD(sfPriceDataSeries,        ARRAY,     24)
 UNTYPED_SFIELD(sfAuthAccounts,           ARRAY,     25)
 UNTYPED_SFIELD(sfAuthorizeCredentials,   ARRAY,     26)

include/xrpl/protocol/detail/transactions.macro

@@ -457,7 +457,111 @@ TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
     {sfAsset2, SoeRequired, SoeMptSupported},
 }))
 
-// 41 to 48 deprecated
+/** This transactions creates a crosschain sequence number */
+#if TRANSACTION_INCLUDE
+#   include <xrpl/tx/transactors/bridge/XChainBridge.h>
+#endif
+TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID,
+    ({.delegable = Delegation::Delegable, .amendment = featureXChainBridge}),
+    ({
+    {sfXChainBridge, SoeRequired},
+    {sfSignatureReward, SoeRequired},
+    {sfOtherChainSource, SoeRequired},
+}))
+
+/** This transactions initiates a crosschain transaction */
+TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit,
+    ({.delegable = Delegation::Delegable, .amendment = featureXChainBridge}),
+    ({
+    {sfXChainBridge, SoeRequired},
+    {sfXChainClaimID, SoeRequired},
+    {sfAmount, SoeRequired},
+    {sfOtherChainDestination, SoeOptional},
+}))
+
+/** This transaction completes a crosschain transaction */
+TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim,
+    ({.delegable = Delegation::Delegable, .amendment = featureXChainBridge}),
+    ({
+    {sfXChainBridge, SoeRequired},
+    {sfXChainClaimID, SoeRequired},
+    {sfDestination, SoeRequired},
+    {sfDestinationTag, SoeOptional},
+    {sfAmount, SoeRequired},
+}))
+
+/** This transaction initiates a crosschain account create transaction */
+TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit,
+    ({.delegable = Delegation::Delegable, .amendment = featureXChainBridge}),
+    ({
+    {sfXChainBridge, SoeRequired},
+    {sfDestination, SoeRequired},
+    {sfAmount, SoeRequired},
+    {sfSignatureReward, SoeRequired},
+}))
+
+/** This transaction adds an attestation to a claim */
+TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation,
+    ({
+        .delegable = Delegation::Delegable,
+        .amendment = featureXChainBridge,
+        .privileges = Privilege::CreateAcct,
+    }),
+    ({
+    {sfXChainBridge, SoeRequired},
+
+    {sfAttestationSignerAccount, SoeRequired},
+    {sfPublicKey, SoeRequired},
+    {sfSignature, SoeRequired},
+    {sfOtherChainSource, SoeRequired},
+    {sfAmount, SoeRequired},
+    {sfAttestationRewardAccount, SoeRequired},
+    {sfWasLockingChainSend, SoeRequired},
+
+    {sfXChainClaimID, SoeRequired},
+    {sfDestination, SoeOptional},
+}))
+
+/** This transaction adds an attestation to an account */
+TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46, XChainAddAccountCreateAttestation,
+    ({
+        .delegable = Delegation::Delegable,
+        .amendment = featureXChainBridge,
+        .privileges = Privilege::CreateAcct,
+    }),
+    ({
+    {sfXChainBridge, SoeRequired},
+
+    {sfAttestationSignerAccount, SoeRequired},
+    {sfPublicKey, SoeRequired},
+    {sfSignature, SoeRequired},
+    {sfOtherChainSource, SoeRequired},
+    {sfAmount, SoeRequired},
+    {sfAttestationRewardAccount, SoeRequired},
+    {sfWasLockingChainSend, SoeRequired},
+
+    {sfXChainAccountCreateCount, SoeRequired},
+    {sfDestination, SoeRequired},
+    {sfSignatureReward, SoeRequired},
+}))
+
+/** This transaction modifies a sidechain */
+TRANSACTION(ttXCHAIN_MODIFY_BRIDGE, 47, XChainModifyBridge,
+    ({.delegable = Delegation::Delegable, .amendment = featureXChainBridge}),
+    ({
+    {sfXChainBridge, SoeRequired},
+    {sfSignatureReward, SoeOptional},
+    {sfMinAccountCreateAmount, SoeOptional},
+}))
+
+/** This transactions creates a sidechain */
+TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge,
+    ({.delegable = Delegation::Delegable, .amendment = featureXChainBridge}),
+    ({
+    {sfXChainBridge, SoeRequired},
+    {sfSignatureReward, SoeRequired},
+    {sfMinAccountCreateAmount, SoeOptional},
+}))
 
 /** This transaction type creates or updates a DID */
 #if TRANSACTION_INCLUDE
@@ -1071,20 +1175,6 @@ TRANSACTION(ttTRANSACTION_PROPOSAL_CREATE, 95, TransactionProposalCreate,
     {sfExpiration, SoeRequired},
 }))
 
-// ttTRANSACTION_PROPOSAL_SIGN arrives in a later PR and takes the next unassigned type.
-
-/** This transaction deletes a TransactionProposal, releasing its owner's
-    reserve. While the proposal is live only its Owner or its target account
-    may cancel; once it is terminal anyone may (On-Chain Cosigner spec §7). */
-#if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/proposal/TransactionProposalCancel.h>
-#endif
-TRANSACTION(ttTRANSACTION_PROPOSAL_CANCEL, 94, TransactionProposalCancel,
-    ({.amendment = featureCosign}),
-    ({
-    {sfProposalID, SoeRequired},
-}))
-
 /** This system-generated transaction type is used to update the status of the various amendments.
 
     For details, see: https://xrpl.org/amendments.html

include/xrpl/protocol/jss.h

@@ -159,6 +159,7 @@ JSS(both);                        // in: Subscribe, Unsubscribe
 JSS(both_sides);                  // in: Subscribe, Unsubscribe
 JSS(branch);                      // out: server_info
 JSS(broadcast);                   // out: SubmitTransaction
+JSS(bridge_account);              // in: LedgerEntry
 JSS(build_path);                  // in: TransactionSign
 JSS(build_version);               // out: NetworkOPs
 JSS(cancel_after);                // out: AccountChannels
@@ -244,16 +245,13 @@ JSS(ephemeral_key);                  // out: ValidatorInfo
 JSS(error);                          // out: error
 JSS(errored);                        //
 JSS(error_code);                     // out: error
-JSS(error_exception);                // out: Submit
+JSS(error_exception);                // out: Submit, Simulate
 JSS(error_message);                  // out: error
 JSS(expand);                         // in: handler/Ledger
 JSS(expected_date);                  // out: any (warnings)
 JSS(expected_date_UTC);              // out: any (warnings)
 JSS(expected_ledger_size);           // out: TxQ
 JSS(expiration);                     // out: AccountOffers, AccountChannels, ValidatorList, amm_info
-JSS(gas_limit);                      // out: NetworkOPs
-JSS(bytecode_size_limit);            // out: NetworkOPs
-JSS(gas_price);                      // out: NetworkOPs
 JSS(fail_hard);                      // in: Sign, Submit
 JSS(failed);                         // out: InboundLedger
 JSS(feature);                        // in: Feature
@@ -561,7 +559,7 @@ JSS(signing_key);                 // out: NetworkOPs
 JSS(signing_keys);                // out: ValidatorList
 JSS(signing_time);                // out: NetworkOPs
 JSS(signer_lists);                // in/out: AccountInfo
-JSS(size);                        // out: get_aggregate_price
+JSS(size);                        // out: get_aggregate_price, ServerHandler
 JSS(snapshot);                    // in: Subscribe
 JSS(source_account);              // in: PathRequest, RipplePathFind
 JSS(source_amount);               // in: PathRequest, RipplePathFind

include/xrpl/protocol_autogen/TransactionBuilderBase.h

@@ -10,6 +10,7 @@
 #include <xrpl/protocol/STInteger.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STXChainBridge.h>
 #include <xrpl/protocol/SecretKey.h>
 #include <xrpl/protocol/Serializer.h>
 #include <xrpl/protocol/TxFormats.h>

include/xrpl/protocol_autogen/ledger_entries/Bridge.h

@@ -0,0 +1,348 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class BridgeBuilder;
+
+/**
+ * @brief Ledger Entry: Bridge
+ *
+ * Type: ltBRIDGE (0x0069)
+ * RPC Name: bridge
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use BridgeBuilder to construct new ledger entries.
+ */
+class Bridge : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltBRIDGE;
+
+    /**
+     * @brief Construct a Bridge ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit Bridge(SLE::const_pointer sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Bridge");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfSignatureReward (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSignatureReward() const
+    {
+        return this->sle_->at(sfSignatureReward);
+    }
+
+    /**
+     * @brief Get sfMinAccountCreateAmount (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getMinAccountCreateAmount() const
+    {
+        if (hasMinAccountCreateAmount())
+            return this->sle_->at(sfMinAccountCreateAmount);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfMinAccountCreateAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasMinAccountCreateAmount() const
+    {
+        return this->sle_->isFieldPresent(sfMinAccountCreateAmount);
+    }
+
+    /**
+     * @brief Get sfXChainBridge (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->sle_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfXChainClaimID (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainClaimID() const
+    {
+        return this->sle_->at(sfXChainClaimID);
+    }
+
+    /**
+     * @brief Get sfXChainAccountCreateCount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainAccountCreateCount() const
+    {
+        return this->sle_->at(sfXChainAccountCreateCount);
+    }
+
+    /**
+     * @brief Get sfXChainAccountClaimCount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainAccountClaimCount() const
+    {
+        return this->sle_->at(sfXChainAccountClaimCount);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for Bridge ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses STObject internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class BridgeBuilder : public LedgerEntryBuilderBase<BridgeBuilder>
+{
+public:
+    /**
+     * @brief Construct a new BridgeBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param signatureReward The sfSignatureReward field value.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param xChainClaimID The sfXChainClaimID field value.
+     * @param xChainAccountCreateCount The sfXChainAccountCreateCount field value.
+     * @param xChainAccountClaimCount The sfXChainAccountClaimCount field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    BridgeBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_AMOUNT::type::value_type> const& signatureReward,std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,std::decay_t<typename SF_UINT64::type::value_type> const& xChainClaimID,std::decay_t<typename SF_UINT64::type::value_type> const& xChainAccountCreateCount,std::decay_t<typename SF_UINT64::type::value_type> const& xChainAccountClaimCount,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<BridgeBuilder>(ltBRIDGE)
+    {
+        setAccount(account);
+        setSignatureReward(signatureReward);
+        setXChainBridge(xChainBridge);
+        setXChainClaimID(xChainClaimID);
+        setXChainAccountCreateCount(xChainAccountCreateCount);
+        setXChainAccountClaimCount(xChainAccountClaimCount);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a BridgeBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    BridgeBuilder(SLE::const_pointer sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltBRIDGE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Bridge");
+        }
+        object_ = *sle;
+    }
+
+    /**
+     * @brief Ledger entry-specific field setters
+     */
+
+    /**
+     * @brief Set sfAccount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignatureReward (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setSignatureReward(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfSignatureReward] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMinAccountCreateAmount (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setMinAccountCreateAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfMinAccountCreateAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainBridge (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainClaimID (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setXChainClaimID(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainClaimID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainAccountCreateCount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setXChainAccountCreateCount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainAccountCreateCount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainAccountClaimCount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setXChainAccountClaimCount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainAccountClaimCount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed Bridge wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    Bridge
+    build(UInt256 const& index)
+    {
+        return Bridge{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/MPToken.h

@@ -316,30 +316,6 @@ public:
         return this->sle_->isFieldPresent(sfAuditorKeyMirrorEpoch);
     }
 
-    /**
-     * @brief Get sfIssuerMirrorEncryptionKey (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_VL::type::value_type>
-    getIssuerMirrorEncryptionKey() const
-    {
-        if (hasIssuerMirrorEncryptionKey())
-            return this->sle_->at(sfIssuerMirrorEncryptionKey);
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfIssuerMirrorEncryptionKey is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasIssuerMirrorEncryptionKey() const
-    {
-        return this->sle_->isFieldPresent(sfIssuerMirrorEncryptionKey);
-    }
-
     /**
      * @brief Get sfHolderEncryptionKey (SoeOptional)
      * @return The field value, or std::nullopt if not present.
@@ -589,17 +565,6 @@ public:
         return *this;
     }
 
-    /**
-     * @brief Set sfIssuerMirrorEncryptionKey (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    MPTokenBuilder&
-    setIssuerMirrorEncryptionKey(std::decay_t<typename SF_VL::type::value_type> const& value)
-    {
-        object_[sfIssuerMirrorEncryptionKey] = value;
-        return *this;
-    }
-
     /**
      * @brief Set sfHolderEncryptionKey (SoeOptional)
      * @return Reference to this builder for method chaining.

include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h

@@ -399,30 +399,6 @@ public:
         return this->sle_->isFieldPresent(sfAuditorKeyEpoch);
     }
 
-    /**
-     * @brief Get sfInitialIssuerEncryptionKey (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_VL::type::value_type>
-    getInitialIssuerEncryptionKey() const
-    {
-        if (hasInitialIssuerEncryptionKey())
-            return this->sle_->at(sfInitialIssuerEncryptionKey);
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfInitialIssuerEncryptionKey is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasInitialIssuerEncryptionKey() const
-    {
-        return this->sle_->isFieldPresent(sfInitialIssuerEncryptionKey);
-    }
-
     /**
      * @brief Get sfConfidentialOutstandingAmount (SoeDefault)
      * @return The field value, or std::nullopt if not present.
@@ -694,17 +670,6 @@ public:
         return *this;
     }
 
-    /**
-     * @brief Set sfInitialIssuerEncryptionKey (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    MPTokenIssuanceBuilder&
-    setInitialIssuerEncryptionKey(std::decay_t<typename SF_VL::type::value_type> const& value)
-    {
-        object_[sfInitialIssuerEncryptionKey] = value;
-        return *this;
-    }
-
     /**
      * @brief Set sfConfidentialOutstandingAmount (SoeDefault)
      * @return Reference to this builder for method chaining.

include/xrpl/protocol_autogen/ledger_entries/Vault.h

@@ -242,54 +242,6 @@ public:
         return this->sle_->isFieldPresent(sfLossUnrealized);
     }
 
-    /**
-     * @brief Get sfYieldUnrealized (SoeDefault)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_NUMBER::type::value_type>
-    getYieldUnrealized() const
-    {
-        if (hasYieldUnrealized())
-            return this->sle_->at(sfYieldUnrealized);
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfYieldUnrealized is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasYieldUnrealized() const
-    {
-        return this->sle_->isFieldPresent(sfYieldUnrealized);
-    }
-
-    /**
-     * @brief Get sfAssetsDeployed (SoeDefault)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_NUMBER::type::value_type>
-    getAssetsDeployed() const
-    {
-        if (hasAssetsDeployed())
-            return this->sle_->at(sfAssetsDeployed);
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfAssetsDeployed is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasAssetsDeployed() const
-    {
-        return this->sle_->isFieldPresent(sfAssetsDeployed);
-    }
-
     /**
      * @brief Get sfShareMPTID (SoeRequired)
      * @return The field value.
@@ -619,28 +571,6 @@ public:
         return *this;
     }
 
-    /**
-     * @brief Set sfYieldUnrealized (SoeDefault)
-     * @return Reference to this builder for method chaining.
-     */
-    VaultBuilder&
-    setYieldUnrealized(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
-    {
-        object_[sfYieldUnrealized] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfAssetsDeployed (SoeDefault)
-     * @return Reference to this builder for method chaining.
-     */
-    VaultBuilder&
-    setAssetsDeployed(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
-    {
-        object_[sfAssetsDeployed] = value;
-        return *this;
-    }
-
     /**
      * @brief Set sfShareMPTID (SoeRequired)
      * @return Reference to this builder for method chaining.

include/xrpl/protocol_autogen/ledger_entries/XChainOwnedClaimID.h

@@ -0,0 +1,314 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class XChainOwnedClaimIDBuilder;
+
+/**
+ * @brief Ledger Entry: XChainOwnedClaimID
+ *
+ * Type: ltXCHAIN_OWNED_CLAIM_ID (0x0071)
+ * RPC Name: xchain_owned_claim_id
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use XChainOwnedClaimIDBuilder to construct new ledger entries.
+ */
+class XChainOwnedClaimID : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltXCHAIN_OWNED_CLAIM_ID;
+
+    /**
+     * @brief Construct a XChainOwnedClaimID ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit XChainOwnedClaimID(SLE::const_pointer sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for XChainOwnedClaimID");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfXChainBridge (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->sle_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfXChainClaimID (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainClaimID() const
+    {
+        return this->sle_->at(sfXChainClaimID);
+    }
+
+    /**
+     * @brief Get sfOtherChainSource (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOtherChainSource() const
+    {
+        return this->sle_->at(sfOtherChainSource);
+    }
+
+    /**
+     * @brief Get sfXChainClaimAttestations (SoeRequired)
+     * @note This is an untyped field (unknown).
+     * @return The field value.
+     */
+    [[nodiscard]]
+    STArray const&
+    getXChainClaimAttestations() const
+    {
+        return this->sle_->getFieldArray(sfXChainClaimAttestations);
+    }
+
+    /**
+     * @brief Get sfSignatureReward (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSignatureReward() const
+    {
+        return this->sle_->at(sfSignatureReward);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for XChainOwnedClaimID ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses STObject internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class XChainOwnedClaimIDBuilder : public LedgerEntryBuilderBase<XChainOwnedClaimIDBuilder>
+{
+public:
+    /**
+     * @brief Construct a new XChainOwnedClaimIDBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param xChainClaimID The sfXChainClaimID field value.
+     * @param otherChainSource The sfOtherChainSource field value.
+     * @param xChainClaimAttestations The sfXChainClaimAttestations field value.
+     * @param signatureReward The sfSignatureReward field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    XChainOwnedClaimIDBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,std::decay_t<typename SF_UINT64::type::value_type> const& xChainClaimID,std::decay_t<typename SF_ACCOUNT::type::value_type> const& otherChainSource,STArray const& xChainClaimAttestations,std::decay_t<typename SF_AMOUNT::type::value_type> const& signatureReward,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<XChainOwnedClaimIDBuilder>(ltXCHAIN_OWNED_CLAIM_ID)
+    {
+        setAccount(account);
+        setXChainBridge(xChainBridge);
+        setXChainClaimID(xChainClaimID);
+        setOtherChainSource(otherChainSource);
+        setXChainClaimAttestations(xChainClaimAttestations);
+        setSignatureReward(signatureReward);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a XChainOwnedClaimIDBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    XChainOwnedClaimIDBuilder(SLE::const_pointer sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltXCHAIN_OWNED_CLAIM_ID)
+        {
+            throw std::runtime_error("Invalid ledger entry type for XChainOwnedClaimID");
+        }
+        object_ = *sle;
+    }
+
+    /**
+     * @brief Ledger entry-specific field setters
+     */
+
+    /**
+     * @brief Set sfAccount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainBridge (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainClaimID (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setXChainClaimID(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainClaimID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOtherChainSource (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setOtherChainSource(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOtherChainSource] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainClaimAttestations (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setXChainClaimAttestations(STArray const& value)
+    {
+        object_.setFieldArray(sfXChainClaimAttestations, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignatureReward (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setSignatureReward(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfSignatureReward] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed XChainOwnedClaimID wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    XChainOwnedClaimID
+    build(UInt256 const& index)
+    {
+        return XChainOwnedClaimID{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/XChainOwnedCreateAccountClaimID.h

@@ -0,0 +1,266 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class XChainOwnedCreateAccountClaimIDBuilder;
+
+/**
+ * @brief Ledger Entry: XChainOwnedCreateAccountClaimID
+ *
+ * Type: ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID (0x0074)
+ * RPC Name: xchain_owned_create_account_claim_id
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use XChainOwnedCreateAccountClaimIDBuilder to construct new ledger entries.
+ */
+class XChainOwnedCreateAccountClaimID : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID;
+
+    /**
+     * @brief Construct a XChainOwnedCreateAccountClaimID ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit XChainOwnedCreateAccountClaimID(SLE::const_pointer sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for XChainOwnedCreateAccountClaimID");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfXChainBridge (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->sle_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfXChainAccountCreateCount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainAccountCreateCount() const
+    {
+        return this->sle_->at(sfXChainAccountCreateCount);
+    }
+
+    /**
+     * @brief Get sfXChainCreateAccountAttestations (SoeRequired)
+     * @note This is an untyped field (unknown).
+     * @return The field value.
+     */
+    [[nodiscard]]
+    STArray const&
+    getXChainCreateAccountAttestations() const
+    {
+        return this->sle_->getFieldArray(sfXChainCreateAccountAttestations);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for XChainOwnedCreateAccountClaimID ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses STObject internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class XChainOwnedCreateAccountClaimIDBuilder : public LedgerEntryBuilderBase<XChainOwnedCreateAccountClaimIDBuilder>
+{
+public:
+    /**
+     * @brief Construct a new XChainOwnedCreateAccountClaimIDBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param xChainAccountCreateCount The sfXChainAccountCreateCount field value.
+     * @param xChainCreateAccountAttestations The sfXChainCreateAccountAttestations field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,std::decay_t<typename SF_UINT64::type::value_type> const& xChainAccountCreateCount,STArray const& xChainCreateAccountAttestations,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<XChainOwnedCreateAccountClaimIDBuilder>(ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID)
+    {
+        setAccount(account);
+        setXChainBridge(xChainBridge);
+        setXChainAccountCreateCount(xChainAccountCreateCount);
+        setXChainCreateAccountAttestations(xChainCreateAccountAttestations);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a XChainOwnedCreateAccountClaimIDBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder(SLE::const_pointer sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID)
+        {
+            throw std::runtime_error("Invalid ledger entry type for XChainOwnedCreateAccountClaimID");
+        }
+        object_ = *sle;
+    }
+
+    /**
+     * @brief Ledger entry-specific field setters
+     */
+
+    /**
+     * @brief Set sfAccount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainBridge (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainAccountCreateCount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setXChainAccountCreateCount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainAccountCreateCount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainCreateAccountAttestations (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setXChainCreateAccountAttestations(STArray const& value)
+    {
+        object_.setFieldArray(sfXChainCreateAccountAttestations, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed XChainOwnedCreateAccountClaimID wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    XChainOwnedCreateAccountClaimID
+    build(UInt256 const& index)
+    {
+        return XChainOwnedCreateAccountClaimID{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/transactions/TransactionProposalCancel.h

@@ -1,131 +0,0 @@
-// This file is auto-generated. Do not edit.
-#pragma once
-
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/STParsedJSON.h>
-#include <xrpl/protocol/jss.h>
-#include <xrpl/protocol_autogen/TransactionBase.h>
-#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
-#include <xrpl/json/json_value.h>
-
-#include <stdexcept>
-#include <optional>
-
-namespace xrpl::transactions {
-
-class TransactionProposalCancelBuilder;
-
-/**
- * @brief Transaction: TransactionProposalCancel
- *
- * Type: ttTRANSACTION_PROPOSAL_CANCEL (94)
- * Delegable: Delegation::NotDelegable
- * Amendment: featureCosign
- * Privileges: Privilege::NoPriv
- *
- * Immutable wrapper around STTx providing type-safe field access.
- * Use TransactionProposalCancelBuilder to construct new transactions.
- */
-class TransactionProposalCancel : public TransactionBase
-{
-public:
-    static constexpr xrpl::TxType txType = ttTRANSACTION_PROPOSAL_CANCEL;
-
-    /**
-     * @brief Construct a TransactionProposalCancel transaction wrapper from an existing STTx object.
-     * @throws std::runtime_error if the transaction type doesn't match.
-     */
-    explicit TransactionProposalCancel(std::shared_ptr<STTx const> tx)
-        : TransactionBase(std::move(tx))
-    {
-        // Verify transaction type
-        if (tx_->getTxnType() != txType)
-        {
-            throw std::runtime_error("Invalid transaction type for TransactionProposalCancel");
-        }
-    }
-
-    // Transaction-specific field getters
-
-    /**
-     * @brief Get sfProposalID (SoeRequired)
-     * @return The field value.
-     */
-    [[nodiscard]]
-    SF_UINT256::type::value_type
-    getProposalID() const
-    {
-        return this->tx_->at(sfProposalID);
-    }
-};
-
-/**
- * @brief Builder for TransactionProposalCancel transactions.
- *
- * Provides a fluent interface for constructing transactions with method chaining.
- * Uses STObject internally for flexible transaction construction.
- * Inherits common field setters from TransactionBuilderBase.
- */
-class TransactionProposalCancelBuilder : public TransactionBuilderBase<TransactionProposalCancelBuilder>
-{
-public:
-    /**
-     * @brief Construct a new TransactionProposalCancelBuilder with required fields.
-     * @param account The account initiating the transaction.
-     * @param proposalID The sfProposalID field value.
-     * @param sequence Optional sequence number for the transaction.
-     * @param fee Optional fee for the transaction.
-     */
-    TransactionProposalCancelBuilder(SF_ACCOUNT::type::value_type account,
-                     std::decay_t<typename SF_UINT256::type::value_type> const& proposalID,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
-                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
-)
-        : TransactionBuilderBase<TransactionProposalCancelBuilder>(ttTRANSACTION_PROPOSAL_CANCEL, account, sequence, fee)
-    {
-        setProposalID(proposalID);
-    }
-
-    /**
-     * @brief Construct a TransactionProposalCancelBuilder from an existing STTx object.
-     * @param tx The existing transaction to copy from.
-     * @throws std::runtime_error if the transaction type doesn't match.
-     */
-    TransactionProposalCancelBuilder(std::shared_ptr<STTx const> tx)
-    {
-        if (tx->getTxnType() != ttTRANSACTION_PROPOSAL_CANCEL)
-        {
-            throw std::runtime_error("Invalid transaction type for TransactionProposalCancelBuilder");
-        }
-        object_ = *tx;
-    }
-
-    /**
-     * @brief Transaction-specific field setters
-     */
-
-    /**
-     * @brief Set sfProposalID (SoeRequired)
-     * @return Reference to this builder for method chaining.
-     */
-    TransactionProposalCancelBuilder&
-    setProposalID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
-    {
-        object_[sfProposalID] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Build and return the TransactionProposalCancel wrapper.
-     * @param publicKey The public key for signing.
-     * @param secretKey The secret key for signing.
-     * @return The constructed transaction wrapper.
-     */
-    TransactionProposalCancel
-    build(PublicKey const& publicKey, SecretKey const& secretKey)
-    {
-        sign(publicKey, secretKey);
-        return TransactionProposalCancel{std::make_shared<STTx>(std::move(object_))};
-    }
-};
-
-}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/XChainAccountCreateCommit.h

@@ -0,0 +1,203 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class XChainAccountCreateCommitBuilder;
+
+/**
+ * @brief Transaction: XChainAccountCreateCommit
+ *
+ * Type: ttXCHAIN_ACCOUNT_CREATE_COMMIT (44)
+ * Delegable: Delegation::Delegable
+ * Amendment: featureXChainBridge
+ * Privileges: Privilege::NoPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use XChainAccountCreateCommitBuilder to construct new transactions.
+ */
+class XChainAccountCreateCommit : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttXCHAIN_ACCOUNT_CREATE_COMMIT;
+
+    /**
+     * @brief Construct a XChainAccountCreateCommit transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit XChainAccountCreateCommit(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainAccountCreateCommit");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfXChainBridge (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->tx_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfDestination (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->tx_->at(sfDestination);
+    }
+
+    /**
+     * @brief Get sfAmount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->tx_->at(sfAmount);
+    }
+
+    /**
+     * @brief Get sfSignatureReward (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSignatureReward() const
+    {
+        return this->tx_->at(sfSignatureReward);
+    }
+};
+
+/**
+ * @brief Builder for XChainAccountCreateCommit transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses STObject internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class XChainAccountCreateCommitBuilder : public TransactionBuilderBase<XChainAccountCreateCommitBuilder>
+{
+public:
+    /**
+     * @brief Construct a new XChainAccountCreateCommitBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param destination The sfDestination field value.
+     * @param amount The sfAmount field value.
+     * @param signatureReward The sfSignatureReward field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    XChainAccountCreateCommitBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination,                     std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,                     std::decay_t<typename SF_AMOUNT::type::value_type> const& signatureReward,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<XChainAccountCreateCommitBuilder>(ttXCHAIN_ACCOUNT_CREATE_COMMIT, account, sequence, fee)
+    {
+        setXChainBridge(xChainBridge);
+        setDestination(destination);
+        setAmount(amount);
+        setSignatureReward(signatureReward);
+    }
+
+    /**
+     * @brief Construct a XChainAccountCreateCommitBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    XChainAccountCreateCommitBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttXCHAIN_ACCOUNT_CREATE_COMMIT)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainAccountCreateCommitBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /**
+     * @brief Transaction-specific field setters
+     */
+
+    /**
+     * @brief Set sfXChainBridge (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAccountCreateCommitBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestination (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAccountCreateCommitBuilder&
+    setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfDestination] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAccountCreateCommitBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignatureReward (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAccountCreateCommitBuilder&
+    setSignatureReward(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfSignatureReward] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the XChainAccountCreateCommit wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    XChainAccountCreateCommit
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return XChainAccountCreateCommit{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/XChainAddAccountCreateAttestation.h

@@ -0,0 +1,371 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class XChainAddAccountCreateAttestationBuilder;
+
+/**
+ * @brief Transaction: XChainAddAccountCreateAttestation
+ *
+ * Type: ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION (46)
+ * Delegable: Delegation::Delegable
+ * Amendment: featureXChainBridge
+ * Privileges: Privilege::CreateAcct
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use XChainAddAccountCreateAttestationBuilder to construct new transactions.
+ */
+class XChainAddAccountCreateAttestation : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION;
+
+    /**
+     * @brief Construct a XChainAddAccountCreateAttestation transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit XChainAddAccountCreateAttestation(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainAddAccountCreateAttestation");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfXChainBridge (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->tx_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfAttestationSignerAccount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAttestationSignerAccount() const
+    {
+        return this->tx_->at(sfAttestationSignerAccount);
+    }
+
+    /**
+     * @brief Get sfPublicKey (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getPublicKey() const
+    {
+        return this->tx_->at(sfPublicKey);
+    }
+
+    /**
+     * @brief Get sfSignature (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getSignature() const
+    {
+        return this->tx_->at(sfSignature);
+    }
+
+    /**
+     * @brief Get sfOtherChainSource (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOtherChainSource() const
+    {
+        return this->tx_->at(sfOtherChainSource);
+    }
+
+    /**
+     * @brief Get sfAmount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->tx_->at(sfAmount);
+    }
+
+    /**
+     * @brief Get sfAttestationRewardAccount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAttestationRewardAccount() const
+    {
+        return this->tx_->at(sfAttestationRewardAccount);
+    }
+
+    /**
+     * @brief Get sfWasLockingChainSend (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT8::type::value_type
+    getWasLockingChainSend() const
+    {
+        return this->tx_->at(sfWasLockingChainSend);
+    }
+
+    /**
+     * @brief Get sfXChainAccountCreateCount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainAccountCreateCount() const
+    {
+        return this->tx_->at(sfXChainAccountCreateCount);
+    }
+
+    /**
+     * @brief Get sfDestination (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->tx_->at(sfDestination);
+    }
+
+    /**
+     * @brief Get sfSignatureReward (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSignatureReward() const
+    {
+        return this->tx_->at(sfSignatureReward);
+    }
+};
+
+/**
+ * @brief Builder for XChainAddAccountCreateAttestation transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses STObject internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class XChainAddAccountCreateAttestationBuilder : public TransactionBuilderBase<XChainAddAccountCreateAttestationBuilder>
+{
+public:
+    /**
+     * @brief Construct a new XChainAddAccountCreateAttestationBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param attestationSignerAccount The sfAttestationSignerAccount field value.
+     * @param publicKey The sfPublicKey field value.
+     * @param signature The sfSignature field value.
+     * @param otherChainSource The sfOtherChainSource field value.
+     * @param amount The sfAmount field value.
+     * @param attestationRewardAccount The sfAttestationRewardAccount field value.
+     * @param wasLockingChainSend The sfWasLockingChainSend field value.
+     * @param xChainAccountCreateCount The sfXChainAccountCreateCount field value.
+     * @param destination The sfDestination field value.
+     * @param signatureReward The sfSignatureReward field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    XChainAddAccountCreateAttestationBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& attestationSignerAccount,                     std::decay_t<typename SF_VL::type::value_type> const& publicKey,                     std::decay_t<typename SF_VL::type::value_type> const& signature,                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& otherChainSource,                     std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& attestationRewardAccount,                     std::decay_t<typename SF_UINT8::type::value_type> const& wasLockingChainSend,                     std::decay_t<typename SF_UINT64::type::value_type> const& xChainAccountCreateCount,                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination,                     std::decay_t<typename SF_AMOUNT::type::value_type> const& signatureReward,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<XChainAddAccountCreateAttestationBuilder>(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, account, sequence, fee)
+    {
+        setXChainBridge(xChainBridge);
+        setAttestationSignerAccount(attestationSignerAccount);
+        setPublicKey(publicKey);
+        setSignature(signature);
+        setOtherChainSource(otherChainSource);
+        setAmount(amount);
+        setAttestationRewardAccount(attestationRewardAccount);
+        setWasLockingChainSend(wasLockingChainSend);
+        setXChainAccountCreateCount(xChainAccountCreateCount);
+        setDestination(destination);
+        setSignatureReward(signatureReward);
+    }
+
+    /**
+     * @brief Construct a XChainAddAccountCreateAttestationBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    XChainAddAccountCreateAttestationBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainAddAccountCreateAttestationBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /**
+     * @brief Transaction-specific field setters
+     */
+
+    /**
+     * @brief Set sfXChainBridge (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddAccountCreateAttestationBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAttestationSignerAccount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddAccountCreateAttestationBuilder&
+    setAttestationSignerAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAttestationSignerAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPublicKey (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddAccountCreateAttestationBuilder&
+    setPublicKey(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfPublicKey] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignature (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddAccountCreateAttestationBuilder&
+    setSignature(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfSignature] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOtherChainSource (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddAccountCreateAttestationBuilder&
+    setOtherChainSource(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOtherChainSource] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddAccountCreateAttestationBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAttestationRewardAccount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddAccountCreateAttestationBuilder&
+    setAttestationRewardAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAttestationRewardAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfWasLockingChainSend (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddAccountCreateAttestationBuilder&
+    setWasLockingChainSend(std::decay_t<typename SF_UINT8::type::value_type> const& value)
+    {
+        object_[sfWasLockingChainSend] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainAccountCreateCount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddAccountCreateAttestationBuilder&
+    setXChainAccountCreateCount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainAccountCreateCount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestination (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddAccountCreateAttestationBuilder&
+    setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfDestination] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignatureReward (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddAccountCreateAttestationBuilder&
+    setSignatureReward(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfSignatureReward] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the XChainAddAccountCreateAttestation wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    XChainAddAccountCreateAttestation
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return XChainAddAccountCreateAttestation{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/XChainAddClaimAttestation.h

@@ -0,0 +1,360 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class XChainAddClaimAttestationBuilder;
+
+/**
+ * @brief Transaction: XChainAddClaimAttestation
+ *
+ * Type: ttXCHAIN_ADD_CLAIM_ATTESTATION (45)
+ * Delegable: Delegation::Delegable
+ * Amendment: featureXChainBridge
+ * Privileges: Privilege::CreateAcct
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use XChainAddClaimAttestationBuilder to construct new transactions.
+ */
+class XChainAddClaimAttestation : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttXCHAIN_ADD_CLAIM_ATTESTATION;
+
+    /**
+     * @brief Construct a XChainAddClaimAttestation transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit XChainAddClaimAttestation(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainAddClaimAttestation");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfXChainBridge (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->tx_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfAttestationSignerAccount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAttestationSignerAccount() const
+    {
+        return this->tx_->at(sfAttestationSignerAccount);
+    }
+
+    /**
+     * @brief Get sfPublicKey (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getPublicKey() const
+    {
+        return this->tx_->at(sfPublicKey);
+    }
+
+    /**
+     * @brief Get sfSignature (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getSignature() const
+    {
+        return this->tx_->at(sfSignature);
+    }
+
+    /**
+     * @brief Get sfOtherChainSource (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOtherChainSource() const
+    {
+        return this->tx_->at(sfOtherChainSource);
+    }
+
+    /**
+     * @brief Get sfAmount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->tx_->at(sfAmount);
+    }
+
+    /**
+     * @brief Get sfAttestationRewardAccount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAttestationRewardAccount() const
+    {
+        return this->tx_->at(sfAttestationRewardAccount);
+    }
+
+    /**
+     * @brief Get sfWasLockingChainSend (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT8::type::value_type
+    getWasLockingChainSend() const
+    {
+        return this->tx_->at(sfWasLockingChainSend);
+    }
+
+    /**
+     * @brief Get sfXChainClaimID (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainClaimID() const
+    {
+        return this->tx_->at(sfXChainClaimID);
+    }
+
+    /**
+     * @brief Get sfDestination (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getDestination() const
+    {
+        if (hasDestination())
+        {
+            return this->tx_->at(sfDestination);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestination is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestination() const
+    {
+        return this->tx_->isFieldPresent(sfDestination);
+    }
+};
+
+/**
+ * @brief Builder for XChainAddClaimAttestation transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses STObject internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class XChainAddClaimAttestationBuilder : public TransactionBuilderBase<XChainAddClaimAttestationBuilder>
+{
+public:
+    /**
+     * @brief Construct a new XChainAddClaimAttestationBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param attestationSignerAccount The sfAttestationSignerAccount field value.
+     * @param publicKey The sfPublicKey field value.
+     * @param signature The sfSignature field value.
+     * @param otherChainSource The sfOtherChainSource field value.
+     * @param amount The sfAmount field value.
+     * @param attestationRewardAccount The sfAttestationRewardAccount field value.
+     * @param wasLockingChainSend The sfWasLockingChainSend field value.
+     * @param xChainClaimID The sfXChainClaimID field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    XChainAddClaimAttestationBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& attestationSignerAccount,                     std::decay_t<typename SF_VL::type::value_type> const& publicKey,                     std::decay_t<typename SF_VL::type::value_type> const& signature,                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& otherChainSource,                     std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& attestationRewardAccount,                     std::decay_t<typename SF_UINT8::type::value_type> const& wasLockingChainSend,                     std::decay_t<typename SF_UINT64::type::value_type> const& xChainClaimID,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<XChainAddClaimAttestationBuilder>(ttXCHAIN_ADD_CLAIM_ATTESTATION, account, sequence, fee)
+    {
+        setXChainBridge(xChainBridge);
+        setAttestationSignerAccount(attestationSignerAccount);
+        setPublicKey(publicKey);
+        setSignature(signature);
+        setOtherChainSource(otherChainSource);
+        setAmount(amount);
+        setAttestationRewardAccount(attestationRewardAccount);
+        setWasLockingChainSend(wasLockingChainSend);
+        setXChainClaimID(xChainClaimID);
+    }
+
+    /**
+     * @brief Construct a XChainAddClaimAttestationBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    XChainAddClaimAttestationBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttXCHAIN_ADD_CLAIM_ATTESTATION)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainAddClaimAttestationBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /**
+     * @brief Transaction-specific field setters
+     */
+
+    /**
+     * @brief Set sfXChainBridge (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddClaimAttestationBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAttestationSignerAccount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddClaimAttestationBuilder&
+    setAttestationSignerAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAttestationSignerAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPublicKey (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddClaimAttestationBuilder&
+    setPublicKey(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfPublicKey] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignature (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddClaimAttestationBuilder&
+    setSignature(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfSignature] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOtherChainSource (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddClaimAttestationBuilder&
+    setOtherChainSource(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOtherChainSource] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddClaimAttestationBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAttestationRewardAccount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddClaimAttestationBuilder&
+    setAttestationRewardAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAttestationRewardAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfWasLockingChainSend (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddClaimAttestationBuilder&
+    setWasLockingChainSend(std::decay_t<typename SF_UINT8::type::value_type> const& value)
+    {
+        object_[sfWasLockingChainSend] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainClaimID (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddClaimAttestationBuilder&
+    setXChainClaimID(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainClaimID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestination (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainAddClaimAttestationBuilder&
+    setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfDestination] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the XChainAddClaimAttestation wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    XChainAddClaimAttestation
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return XChainAddClaimAttestation{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/XChainClaim.h

@@ -0,0 +1,240 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class XChainClaimBuilder;
+
+/**
+ * @brief Transaction: XChainClaim
+ *
+ * Type: ttXCHAIN_CLAIM (43)
+ * Delegable: Delegation::Delegable
+ * Amendment: featureXChainBridge
+ * Privileges: Privilege::NoPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use XChainClaimBuilder to construct new transactions.
+ */
+class XChainClaim : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttXCHAIN_CLAIM;
+
+    /**
+     * @brief Construct a XChainClaim transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit XChainClaim(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainClaim");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfXChainBridge (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->tx_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfXChainClaimID (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainClaimID() const
+    {
+        return this->tx_->at(sfXChainClaimID);
+    }
+
+    /**
+     * @brief Get sfDestination (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->tx_->at(sfDestination);
+    }
+
+    /**
+     * @brief Get sfDestinationTag (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+        {
+            return this->tx_->at(sfDestinationTag);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestinationTag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->tx_->isFieldPresent(sfDestinationTag);
+    }
+
+    /**
+     * @brief Get sfAmount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->tx_->at(sfAmount);
+    }
+};
+
+/**
+ * @brief Builder for XChainClaim transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses STObject internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class XChainClaimBuilder : public TransactionBuilderBase<XChainClaimBuilder>
+{
+public:
+    /**
+     * @brief Construct a new XChainClaimBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param xChainClaimID The sfXChainClaimID field value.
+     * @param destination The sfDestination field value.
+     * @param amount The sfAmount field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    XChainClaimBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,                     std::decay_t<typename SF_UINT64::type::value_type> const& xChainClaimID,                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination,                     std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<XChainClaimBuilder>(ttXCHAIN_CLAIM, account, sequence, fee)
+    {
+        setXChainBridge(xChainBridge);
+        setXChainClaimID(xChainClaimID);
+        setDestination(destination);
+        setAmount(amount);
+    }
+
+    /**
+     * @brief Construct a XChainClaimBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    XChainClaimBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttXCHAIN_CLAIM)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainClaimBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /**
+     * @brief Transaction-specific field setters
+     */
+
+    /**
+     * @brief Set sfXChainBridge (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainClaimBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainClaimID (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainClaimBuilder&
+    setXChainClaimID(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainClaimID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestination (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainClaimBuilder&
+    setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfDestination] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestinationTag (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainClaimBuilder&
+    setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfDestinationTag] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainClaimBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the XChainClaim wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    XChainClaim
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return XChainClaim{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/XChainCommit.h

@@ -0,0 +1,216 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class XChainCommitBuilder;
+
+/**
+ * @brief Transaction: XChainCommit
+ *
+ * Type: ttXCHAIN_COMMIT (42)
+ * Delegable: Delegation::Delegable
+ * Amendment: featureXChainBridge
+ * Privileges: Privilege::NoPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use XChainCommitBuilder to construct new transactions.
+ */
+class XChainCommit : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttXCHAIN_COMMIT;
+
+    /**
+     * @brief Construct a XChainCommit transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit XChainCommit(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainCommit");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfXChainBridge (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->tx_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfXChainClaimID (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainClaimID() const
+    {
+        return this->tx_->at(sfXChainClaimID);
+    }
+
+    /**
+     * @brief Get sfAmount (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->tx_->at(sfAmount);
+    }
+
+    /**
+     * @brief Get sfOtherChainDestination (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getOtherChainDestination() const
+    {
+        if (hasOtherChainDestination())
+        {
+            return this->tx_->at(sfOtherChainDestination);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfOtherChainDestination is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasOtherChainDestination() const
+    {
+        return this->tx_->isFieldPresent(sfOtherChainDestination);
+    }
+};
+
+/**
+ * @brief Builder for XChainCommit transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses STObject internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class XChainCommitBuilder : public TransactionBuilderBase<XChainCommitBuilder>
+{
+public:
+    /**
+     * @brief Construct a new XChainCommitBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param xChainClaimID The sfXChainClaimID field value.
+     * @param amount The sfAmount field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    XChainCommitBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,                     std::decay_t<typename SF_UINT64::type::value_type> const& xChainClaimID,                     std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<XChainCommitBuilder>(ttXCHAIN_COMMIT, account, sequence, fee)
+    {
+        setXChainBridge(xChainBridge);
+        setXChainClaimID(xChainClaimID);
+        setAmount(amount);
+    }
+
+    /**
+     * @brief Construct a XChainCommitBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    XChainCommitBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttXCHAIN_COMMIT)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainCommitBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /**
+     * @brief Transaction-specific field setters
+     */
+
+    /**
+     * @brief Set sfXChainBridge (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainCommitBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainClaimID (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainCommitBuilder&
+    setXChainClaimID(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainClaimID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainCommitBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOtherChainDestination (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainCommitBuilder&
+    setOtherChainDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOtherChainDestination] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the XChainCommit wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    XChainCommit
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return XChainCommit{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/XChainCreateBridge.h

@@ -0,0 +1,192 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class XChainCreateBridgeBuilder;
+
+/**
+ * @brief Transaction: XChainCreateBridge
+ *
+ * Type: ttXCHAIN_CREATE_BRIDGE (48)
+ * Delegable: Delegation::Delegable
+ * Amendment: featureXChainBridge
+ * Privileges: Privilege::NoPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use XChainCreateBridgeBuilder to construct new transactions.
+ */
+class XChainCreateBridge : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttXCHAIN_CREATE_BRIDGE;
+
+    /**
+     * @brief Construct a XChainCreateBridge transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit XChainCreateBridge(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainCreateBridge");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfXChainBridge (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->tx_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfSignatureReward (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSignatureReward() const
+    {
+        return this->tx_->at(sfSignatureReward);
+    }
+
+    /**
+     * @brief Get sfMinAccountCreateAmount (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getMinAccountCreateAmount() const
+    {
+        if (hasMinAccountCreateAmount())
+        {
+            return this->tx_->at(sfMinAccountCreateAmount);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfMinAccountCreateAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasMinAccountCreateAmount() const
+    {
+        return this->tx_->isFieldPresent(sfMinAccountCreateAmount);
+    }
+};
+
+/**
+ * @brief Builder for XChainCreateBridge transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses STObject internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class XChainCreateBridgeBuilder : public TransactionBuilderBase<XChainCreateBridgeBuilder>
+{
+public:
+    /**
+     * @brief Construct a new XChainCreateBridgeBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param signatureReward The sfSignatureReward field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    XChainCreateBridgeBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,                     std::decay_t<typename SF_AMOUNT::type::value_type> const& signatureReward,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<XChainCreateBridgeBuilder>(ttXCHAIN_CREATE_BRIDGE, account, sequence, fee)
+    {
+        setXChainBridge(xChainBridge);
+        setSignatureReward(signatureReward);
+    }
+
+    /**
+     * @brief Construct a XChainCreateBridgeBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    XChainCreateBridgeBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttXCHAIN_CREATE_BRIDGE)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainCreateBridgeBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /**
+     * @brief Transaction-specific field setters
+     */
+
+    /**
+     * @brief Set sfXChainBridge (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainCreateBridgeBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignatureReward (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainCreateBridgeBuilder&
+    setSignatureReward(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfSignatureReward] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMinAccountCreateAmount (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainCreateBridgeBuilder&
+    setMinAccountCreateAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfMinAccountCreateAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the XChainCreateBridge wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    XChainCreateBridge
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return XChainCreateBridge{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/XChainCreateClaimID.h

@@ -0,0 +1,179 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class XChainCreateClaimIDBuilder;
+
+/**
+ * @brief Transaction: XChainCreateClaimID
+ *
+ * Type: ttXCHAIN_CREATE_CLAIM_ID (41)
+ * Delegable: Delegation::Delegable
+ * Amendment: featureXChainBridge
+ * Privileges: Privilege::NoPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use XChainCreateClaimIDBuilder to construct new transactions.
+ */
+class XChainCreateClaimID : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttXCHAIN_CREATE_CLAIM_ID;
+
+    /**
+     * @brief Construct a XChainCreateClaimID transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit XChainCreateClaimID(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainCreateClaimID");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfXChainBridge (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->tx_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfSignatureReward (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSignatureReward() const
+    {
+        return this->tx_->at(sfSignatureReward);
+    }
+
+    /**
+     * @brief Get sfOtherChainSource (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOtherChainSource() const
+    {
+        return this->tx_->at(sfOtherChainSource);
+    }
+};
+
+/**
+ * @brief Builder for XChainCreateClaimID transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses STObject internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class XChainCreateClaimIDBuilder : public TransactionBuilderBase<XChainCreateClaimIDBuilder>
+{
+public:
+    /**
+     * @brief Construct a new XChainCreateClaimIDBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param signatureReward The sfSignatureReward field value.
+     * @param otherChainSource The sfOtherChainSource field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    XChainCreateClaimIDBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,                     std::decay_t<typename SF_AMOUNT::type::value_type> const& signatureReward,                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& otherChainSource,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<XChainCreateClaimIDBuilder>(ttXCHAIN_CREATE_CLAIM_ID, account, sequence, fee)
+    {
+        setXChainBridge(xChainBridge);
+        setSignatureReward(signatureReward);
+        setOtherChainSource(otherChainSource);
+    }
+
+    /**
+     * @brief Construct a XChainCreateClaimIDBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    XChainCreateClaimIDBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttXCHAIN_CREATE_CLAIM_ID)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainCreateClaimIDBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /**
+     * @brief Transaction-specific field setters
+     */
+
+    /**
+     * @brief Set sfXChainBridge (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainCreateClaimIDBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignatureReward (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainCreateClaimIDBuilder&
+    setSignatureReward(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfSignatureReward] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOtherChainSource (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainCreateClaimIDBuilder&
+    setOtherChainSource(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOtherChainSource] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the XChainCreateClaimID wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    XChainCreateClaimID
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return XChainCreateClaimID{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/XChainModifyBridge.h

@@ -0,0 +1,205 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class XChainModifyBridgeBuilder;
+
+/**
+ * @brief Transaction: XChainModifyBridge
+ *
+ * Type: ttXCHAIN_MODIFY_BRIDGE (47)
+ * Delegable: Delegation::Delegable
+ * Amendment: featureXChainBridge
+ * Privileges: Privilege::NoPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use XChainModifyBridgeBuilder to construct new transactions.
+ */
+class XChainModifyBridge : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttXCHAIN_MODIFY_BRIDGE;
+
+    /**
+     * @brief Construct a XChainModifyBridge transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit XChainModifyBridge(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainModifyBridge");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfXChainBridge (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->tx_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfSignatureReward (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getSignatureReward() const
+    {
+        if (hasSignatureReward())
+        {
+            return this->tx_->at(sfSignatureReward);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfSignatureReward is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasSignatureReward() const
+    {
+        return this->tx_->isFieldPresent(sfSignatureReward);
+    }
+
+    /**
+     * @brief Get sfMinAccountCreateAmount (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getMinAccountCreateAmount() const
+    {
+        if (hasMinAccountCreateAmount())
+        {
+            return this->tx_->at(sfMinAccountCreateAmount);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfMinAccountCreateAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasMinAccountCreateAmount() const
+    {
+        return this->tx_->isFieldPresent(sfMinAccountCreateAmount);
+    }
+};
+
+/**
+ * @brief Builder for XChainModifyBridge transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses STObject internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class XChainModifyBridgeBuilder : public TransactionBuilderBase<XChainModifyBridgeBuilder>
+{
+public:
+    /**
+     * @brief Construct a new XChainModifyBridgeBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    XChainModifyBridgeBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<XChainModifyBridgeBuilder>(ttXCHAIN_MODIFY_BRIDGE, account, sequence, fee)
+    {
+        setXChainBridge(xChainBridge);
+    }
+
+    /**
+     * @brief Construct a XChainModifyBridgeBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    XChainModifyBridgeBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttXCHAIN_MODIFY_BRIDGE)
+        {
+            throw std::runtime_error("Invalid transaction type for XChainModifyBridgeBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /**
+     * @brief Transaction-specific field setters
+     */
+
+    /**
+     * @brief Set sfXChainBridge (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainModifyBridgeBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignatureReward (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainModifyBridgeBuilder&
+    setSignatureReward(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfSignatureReward] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMinAccountCreateAmount (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainModifyBridgeBuilder&
+    setMinAccountCreateAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfMinAccountCreateAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the XChainModifyBridge wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    XChainModifyBridge
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return XChainModifyBridge{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/server/InfoSub.h

@@ -17,6 +17,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <string>
 
 namespace xrpl {
@@ -57,6 +58,87 @@ exceedsSubscriptionCap(
     return additional > cap || current > cap - additional;
 }
 
+/**
+ * Returns @p jvObj reshaped as a JSON-RPC 2.0 notification, or nullopt when the
+ * message already has the shape @p apiVersion expects.
+ *
+ * From version 3 a message a subscription pushes is shaped as the
+ * specification's notification: an object naming the protocol and the method,
+ * the message's content under `params`, and no `id`. The `type` naming the
+ * event becomes the `method`.
+ *
+ * A path finding update is one of these, though directed at the one subscriber
+ * that asked: the specification allows one response per request and
+ * `path_find create` consumed it. The `id` the client correlates by travels
+ * inside `params`, where the update carries it.
+ *
+ * A message naming no `type`, or one whose `type` is not a string, names no
+ * method, so it is passed through unshaped. Shaping reports that `type` as the
+ * `method` and leaves none behind, so shaping a message a second time changes
+ * nothing.
+ *
+ * @param jvObj The message to shape.
+ * @param apiVersion The subscriber's API version.
+ * @return The notification, or nullopt if no reshaping is needed.
+ */
+[[nodiscard]] std::optional<json::Value>
+shapeAsNotification(json::Value const& jvObj, unsigned int apiVersion);
+
+/**
+ * Returns a copy of the stream error @p error naming @p stream as its `type`,
+ * or nullopt when the error is sent as it stands.
+ *
+ * An error object names no `type`, so shapeAsNotification would pass it
+ * through and a version 3 client could not classify it. The name is added only
+ * where a notification is built from it: for a version below 3, or a subscriber
+ * that cannot receive a notification, the object goes out unshaped and the
+ * member would reach the wire undefined. Nothing is copied in that case.
+ *
+ * @param error The error a stream reports, as rpcError builds it.
+ * @param apiVersion The subscriber's API version.
+ * @param wantsNotifications Whether the subscriber can receive a notification.
+ *        See InfoSub::wantsNotifications.
+ * @param stream The stream the error concerns, which becomes the `method`.
+ * @return The stamped copy, or nullopt if the error needs no name.
+ */
+[[nodiscard]] std::optional<json::Value>
+stampStreamError(
+    json::Value const& error,
+    unsigned int apiVersion,
+    bool wantsNotifications,
+    json::StaticString const& stream);
+
+class InfoSub;
+
+/**
+ * Sends @p jvObj to @p subscriber in the shape @p apiVersion expects.
+ *
+ * The version belongs to the subscription the message answers, so the caller
+ * passes it from the entry it took the subscriber from. A `path_find` update
+ * is served at the version its own request named, which can differ from the
+ * version the connection's subscriptions are served at, and one webhook may
+ * be shared by several callers.
+ *
+ * A shape is not transport-independent either, so a subscriber whose transport
+ * cannot carry a notification is sent the message as the publisher built it.
+ * See InfoSub::wantsNotifications.
+ *
+ * Every caller shapes for the one subscriber in front of it, so a stream event
+ * reaching many subscribers is shaped once for each of them.
+ *
+ * @param subscriber Where the message is going.
+ * @param apiVersion The version the subscription was registered at.
+ * @param jvObj The message.
+ * @param broadcast Whether the message was published to a stream rather than
+ *        directed at this subscriber. Only a diagnostic reads it.
+ */
+void
+sendShaped(
+    InfoSub& subscriber,
+    unsigned int apiVersion,
+    json::Value const& jvObj,
+    bool broadcast = true);
+
 class InfoSubRequest : public CountedObject<InfoSubRequest>
 {
 public:
@@ -113,7 +195,11 @@ public:
         // you get transactions as they occur or once their
         // results are confirmed
         virtual void
-        subAccount(Ref ispListener, HashSet<AccountID> const& vnaAccountIDs, bool realTime) = 0;
+        subAccount(
+            Ref ispListener,
+            HashSet<AccountID> const& vnaAccountIDs,
+            bool realTime,
+            unsigned int apiVersion) = 0;
 
         // for normal use, removes from InfoSub and server
         virtual void
@@ -130,10 +216,12 @@ public:
         /**
          * subscribe an account's new transactions and retrieve the account's
          * historical transactions
+         * @param apiVersion The version the subscription is registered at,
+         *        which is the version its messages are shaped for.
          * @return rpcSUCCESS if successful, otherwise an error code
          */
         virtual ErrorCodeI
-        subAccountHistory(Ref ispListener, AccountID const& account) = 0;
+        subAccountHistory(Ref ispListener, AccountID const& account, unsigned int apiVersion) = 0;
 
         /**
          * unsubscribe an account's transactions
@@ -196,30 +284,34 @@ public:
             HashSet<AccountID> historyAccounts) = 0;
 
         // VFALCO TODO Document the bool return value
+        //
+        // Every sub* below takes the version the subscription is registered at, which is the
+        // version its messages are shaped for. Registering the same subscription again replaces
+        // the entry, so the newest registration decides that subscription's version.
         virtual bool
-        subLedger(Ref ispListener, json::Value& jvResult) = 0;
+        subLedger(Ref ispListener, json::Value& jvResult, unsigned int apiVersion) = 0;
         virtual bool
         unsubLedger(std::uint64_t uListener) = 0;
 
         virtual bool
-        subBookChanges(Ref ispListener) = 0;
+        subBookChanges(Ref ispListener, unsigned int apiVersion) = 0;
         virtual bool
         unsubBookChanges(std::uint64_t uListener) = 0;
 
         virtual bool
-        subManifests(Ref ispListener) = 0;
+        subManifests(Ref ispListener, unsigned int apiVersion) = 0;
         virtual bool
         unsubManifests(std::uint64_t uListener) = 0;
         virtual void
         pubManifest(Manifest const&) = 0;
 
         virtual bool
-        subServer(Ref ispListener, json::Value& jvResult, bool admin) = 0;
+        subServer(Ref ispListener, json::Value& jvResult, bool admin, unsigned int apiVersion) = 0;
         virtual bool
         unsubServer(std::uint64_t uListener) = 0;
 
         virtual bool
-        subBook(Ref ispListener, Book const&) = 0;
+        subBook(Ref ispListener, Book const&, unsigned int apiVersion) = 0;
 
         /**
          * Remove a book subscription for a live subscriber.
@@ -248,7 +340,8 @@ public:
          * InfoSub::bookSubscriptions_ because the InfoSub is being destroyed.
          * Called by ~InfoSub() for each book in bookSubscriptions_.
          *
-         * @param uListener The sequence number of the subscriber being torn down.
+         * @param uListener The sequence number of the subscriber being torn
+         *        down.
          * @param book      The order book entry to remove.
          * @return true if the entry was present and removed, false otherwise
          * (e.g., already removed by a concurrent RPC unsubscribe).
@@ -259,22 +352,22 @@ public:
         unsubBookInternal(std::uint64_t uListener, Book const&) = 0;
 
         virtual bool
-        subTransactions(Ref ispListener) = 0;
+        subTransactions(Ref ispListener, unsigned int apiVersion) = 0;
         virtual bool
         unsubTransactions(std::uint64_t uListener) = 0;
 
         virtual bool
-        subRTTransactions(Ref ispListener) = 0;
+        subRTTransactions(Ref ispListener, unsigned int apiVersion) = 0;
         virtual bool
         unsubRTTransactions(std::uint64_t uListener) = 0;
 
         virtual bool
-        subValidations(Ref ispListener) = 0;
+        subValidations(Ref ispListener, unsigned int apiVersion) = 0;
         virtual bool
         unsubValidations(std::uint64_t uListener) = 0;
 
         virtual bool
-        subPeerStatus(Ref ispListener) = 0;
+        subPeerStatus(Ref ispListener, unsigned int apiVersion) = 0;
 
         virtual bool
         unsubPeerStatus(std::uint64_t uListener) = 0;
@@ -282,12 +375,12 @@ public:
         pubPeerStatus(std::function<json::Value()> const&) = 0;
 
         virtual bool
-        subConsensus(Ref ispListener) = 0;
+        subConsensus(Ref ispListener, unsigned int apiVersion) = 0;
         virtual bool
         unsubConsensus(std::uint64_t uListener) = 0;
 
         virtual void
-        subMPT(InfoSub::Ref ispListener, HashSet<MPTID> const& mptIDs) = 0;
+        subMPT(InfoSub::Ref ispListener, HashSet<MPTID> const& mptIDs, unsigned int apiVersion) = 0;
         virtual void
         unsubMPT(InfoSub::Ref ispListener, HashSet<MPTID> const& mptIDs) = 0;
 
@@ -320,9 +413,41 @@ public:
     Consumer&
     getConsumer();
 
+    /**
+     * Deliver a message to this subscriber.
+     *
+     * @param jvObj The message.
+     * @param broadcast True for a stream event published to every subscriber of
+     *        that stream, false for one directed at this subscriber alone
+     *        because it asked (a path finding update). Both are shaped the same
+     *        way, since neither is a response. This reports only how far the
+     *        message traveled, which is what a diagnostic reads.
+     */
     virtual void
     send(json::Value const& jvObj, bool broadcast) = 0;
 
+    /**
+     * Whether a message sent to this subscriber may be shaped as a JSON-RPC
+     * 2.0 notification.
+     *
+     * True for a subscriber the server writes a message to as it is, which
+     * every WebSocket session is. False for one whose transport puts what it
+     * is given inside another request, which a subscriber named by a url does:
+     * a notification would reach it nested in a request and beside a member
+     * the specification does not define, so it would not be a notification at
+     * all. Such a subscriber receives the message as the publisher built it, at
+     * every API version.
+     *
+     * A publisher that shapes a message asks this first.
+     *
+     * @return true if a notification is a shape this subscriber can receive.
+     */
+    [[nodiscard]] virtual bool
+    wantsNotifications() const noexcept
+    {
+        return true;
+    }
+
     [[nodiscard]] std::uint64_t
     getSeq() const;
 
@@ -385,8 +510,9 @@ public:
     /**
      * Whether this connection already tracks an account-history for @p account.
      *
-     * `doSubscribe` reads this to charge the cap for an account_history_tx_stream
-     * only when it is net-new, matching the account branches.
+     * `doSubscribe` reads this to charge the cap for an
+     * account_history_tx_stream only when it is net-new, matching the account
+     * branches.
      *
      * @param account The account an account_history_tx_stream would add.
      * @return true if @p account is already in the account-history set.
@@ -447,11 +573,26 @@ public:
     std::shared_ptr<InfoSubRequest> const&
     getRequest();
 
-    void
-    setApiVersion(unsigned int apiVersion);
-
-    [[nodiscard]] unsigned int
-    getApiVersion() const noexcept;
+    /**
+     * Establishes @p apiVersion as the version every subscription on this
+     * connection is served at.
+     *
+     * A connection serves one version: one message has one shape, and several
+     * of its subscriptions may match it. The first `subscribe` decides it and
+     * it is never cleared. A `subscribe` refused for another reason still
+     * establishes it, the registrations it makes being spread through the
+     * handler.
+     *
+     * For the subscribe path alone. Nothing reads this value back: a publisher
+     * reads the version recorded on the subscription it took the sink from.
+     *
+     * @param apiVersion The version the `subscribe` named.
+     * @return nullopt when @p apiVersion is this connection's version;
+     *         otherwise the version already established.
+     * @note Thread-safe: takes `lock_`.
+     */
+    [[nodiscard]] std::optional<unsigned int>
+    establishSubscriptionVersion(unsigned int apiVersion);
 
     void
     insertSubMPTInfo(MPTID const& mptID);
@@ -485,9 +626,20 @@ private:
     HashSet<AccountID> accountHistorySubscriptions_;
     HashSet<Book> bookSubscriptions_;
     HashSet<MPTID> mptSubscriptions_;
-    unsigned int apiVersion_ = 0;
+    // The API version every subscription on this connection was registered at, set by the first
+    // `subscribe` and never cleared. Guarded by lock_. Read only by establishSubscriptionVersion,
+    // so no publisher can reach it.
+    std::optional<unsigned int> subscriptionApiVersion_;
 
-    static int
+    /**
+     * The next sequence number, which is what identifies a connection.
+     *
+     * 64 bits wide, as the counter and `seq_` are, so no two live connections
+     * share an identity.
+     *
+     * @return A sequence number no live connection holds.
+     */
+    static std::uint64_t
     assignId()
     {
         static std::atomic<std::uint64_t> kID(0);

include/xrpl/server/detail/JSONRPCUtil.h

@@ -7,6 +7,20 @@
 
 namespace xrpl {
 
+/**
+ * Writes an HTTP reply carrying @p strMsg with status @p nStatus to @p output,
+ * and logs the status at trace. The body is not logged here: it may carry a
+ * credential this library cannot mask, so the caller logs it masked.
+ *
+ * A 401 with an empty body is answered with the fixed authentication page.
+ * The status line carries the phrase Beast's registry gives @p nStatus, except
+ * for 401 and 503, which carry a phrase of this server's own.
+ *
+ * @param nStatus The HTTP status code.
+ * @param strMsg The body.
+ * @param output Where the reply bytes are written.
+ * @param j The journal the status is logged to.
+ */
 void
 httpReply(int nStatus, std::string const& strMsg, json::Output const&, beast::Journal j);
 

include/xrpl/shamap/SHAMap.h

@@ -2,7 +2,6 @@
 
 #include <xrpl/basics/Blob.h>
 #include <xrpl/basics/IntrusivePointer.h>
-#include <xrpl/basics/Log.h>
 #include <xrpl/basics/SHAMapHash.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/utility/Journal.h>
@@ -18,7 +17,6 @@
 #include <xrpl/shamap/SHAMapNodeID.h>
 #include <xrpl/shamap/SHAMapTreeNode.h>
 
-#include <atomic>
 #include <condition_variable>
 #include <cstddef>
 #include <cstdint>
@@ -42,7 +40,7 @@ class SHAMapSyncFilter;
 /**
  * Describes the current state of a given SHAMap
  */
-enum class SHAMapState : std::uint8_t {
+enum class SHAMapState {
     /**
      * The map is in flux and objects can be added and removed.
      *
@@ -122,42 +120,16 @@ private:
      */
     std::uint32_t cowid_ = 1;
 
-    // ledgerSeq_, state_ and full_ are touched on the nodestore fetch path and on a
-    // getMissingNodes() walk, neither of which may block, so pin them lock-free.
-    static_assert(std::atomic<std::uint32_t>::is_always_lock_free);
-    static_assert(std::atomic<SHAMapState>::is_always_lock_free);
-    static_assert(std::atomic<bool>::is_always_lock_free);
-
     /**
      * The sequence of the ledger that this map references, if any.
-     *
-     * Written when a map's ledger sequence is established (Ledger::setFull(),
-     * InboundLedger) while a nodestore reader thread reads it. Relaxed either
-     * way: it serves as a lookup hint for a nodestore keyed by hash.
      */
-    std::atomic<std::uint32_t> ledgerSeq_ = 0;
+    std::uint32_t ledgerSeq_ = 0;
 
     SHAMapTreeNodePtr root_;
-
-    /**
-     * The map's state.
-     *
-     * A getMissingNodes() walk writes it, through setInvalid() and
-     * clearSynching(), while whatever drives the acquisition reads it.
-     * The walk runs with the acquisition's lock released, so this is atomic
-     * rather than guarded.
-     */
-    mutable std::atomic<SHAMapState> state_;
+    mutable SHAMapState state_;
     SHAMapType const type_;
-    bool backed_ = true;  // Map is backed by the database
-
-    /**
-     * Map is believed complete in database.
-     *
-     * Atomic because finishFetch() clears it on any nodestore reader thread,
-     * several of which can run at once.
-     */
-    mutable std::atomic<bool> full_ = false;
+    bool backed_ = true;         // Map is backed by the database
+    mutable bool full_ = false;  // Map is believed complete in database
 
 public:
     /**
@@ -180,14 +152,7 @@ public:
     SHAMap&
     operator=(SHAMap const&) = delete;
 
-    /**
-     * Take a snapshot of the given map.
-     *
-     * @param other The map to snapshot. An Invalid source yields an Invalid
-     *        snapshot.
-     * @param isMutable Whether the snapshot may be modified. Ignored when other
-     *        is Invalid.
-     */
+    // Take a snapshot of the given map:
     SHAMap(SHAMap const& other, bool isMutable);
 
     // build new map
@@ -225,33 +190,17 @@ public:
 
     //--------------------------------------------------------------------------
 
-    /**
-     * Return a new map that is a snapshot of this one.
-     *
-     * Handles copy on write for mutable snapshots. An invalid map yields an
-     * invalid snapshot.
-     *
-     * @param isMutable Whether the snapshot may be modified.
-     * @return The snapshot.
-     */
+    // Returns a new map that's a snapshot of this one.
+    // Handles copy on write for mutable snapshots.
     std::shared_ptr<SHAMap>
     snapShot(bool isMutable) const;
 
-    /**
-     * Mark this map as "should be full": the local server wants every node
-     * it references in durable storage, so a nodestore miss is a gap to report.
-     *
-     * Publishes the ledger sequence before the flag. The sequence store is
-     * relaxed and the flag store is release, and finishFetch() reads the
-     * sequence only after acquiring the flag, so the one miss that withdraws
-     * the flag always reports the sequence stored here. Keeping both stores in
-     * one place is what makes that order impossible to get wrong.
-     *
-     * @param ledgerSeq Sequence of the ledger this map belongs to, which the
-     *        gap report names.
-     */
+    /*  Mark this SHAMap as "should be full", indicating
+        that the local server wants all the corresponding nodes
+        in durable storage.
+    */
     void
-    setFull(std::uint32_t ledgerSeq);
+    setFull();
 
     void
     setLedgerSeq(std::uint32_t lseq);
@@ -347,13 +296,9 @@ public:
      * concurrency, to discover nodes referenced in the
      * SHAMap but not available locally.
      *
-     * Only a leaf may occupy a position at or beyond kLeafDepth. A map that
-     * breaks that is marked Invalid and the traversal is abandoned, so callers
-     * ask isValid() to tell an empty result from a satisfied map.
-     *
      * @param maxNodes The maximum number of found nodes to return
      * @param filter The filter to use when retrieving nodes
-     * @return The nodes known to be missing, or empty if the map is Invalid
+     * @param return The nodes known to be missing
      */
     std::vector<std::pair<SHAMapNodeID, UInt256>>
     getMissingNodes(int maxNodes, SHAMapSyncFilter const* filter);
@@ -396,9 +341,6 @@ public:
      * This function is used when receiving the root node of a SHAMap from a peer during ledger
      * synchronization. The node must already have been deserialized.
      *
-     * A root offered under a hash the map does not hold names another tree and
-     * is reported as invalid data. A root matching that hash is a duplicate.
-     *
      * @param hash The expected hash of the root node.
      * @param rootNode A deserialized root node to add.
      * @param filter Optional sync filter to track received nodes.
@@ -418,10 +360,6 @@ public:
      * is inserted at the position specified by nodeID. The node must already have been
      * deserialized.
      *
-     * A node that no valid tree can hold makes the map Invalid, which is
-     * terminal: the root hash committed to an impossible shape, so no peer
-     * can satisfy it.
-     *
      * @param nodeID The position in the tree where this node belongs.
      * @param treeNode A deserialized tree node to add.
      * @param filter Optional sync filter to track received nodes.
@@ -437,57 +375,16 @@ public:
         SHAMapTreeNodePtr treeNode,
         SHAMapSyncFilter const* filter);
 
-    /**
-     * Mark this map as immutable, so it can no longer be modified.
-     *
-     * @return false if the map is Invalid and was left unchanged, true
-     *         otherwise.
-     */
-    [[nodiscard]] bool
+    // status functions
+    void
     setImmutable();
-
-    /**
-     * @return Whether the map is being synced against a hash it was given, so
-     *         its hash is fixed while nodes may still be added.
-     */
-    [[nodiscard]] bool
+    bool
     isSynching() const;
-
-    /**
-     * @return Whether the map is settled, with its hash and nodes fixed.
-     */
-    [[nodiscard]] bool
-    isImmutable() const;
-
-    /**
-     * Mark this map as syncing, fixing its hash while still allowing missing
-     * nodes to be added.
-     *
-     * The map must be freshly constructed. The body asserts that the map is not
-     * Invalid, so a caller that ignores the precondition stops a build with
-     * assertions enabled.
-     */
     void
     setSynching();
-
-    /**
-     * Mark this map as no longer syncing, so it can be modified again.
-     *
-     * Moves only a Synching map. An Immutable map stays settled, a Modifying
-     * map has nothing to clear, and Invalid is terminal.
-     */
     void
     clearSynching();
-
-    /**
-     * Whether the map can still be the map it claims to be.
-     *
-     * A map that is merely missing nodes is valid, and stays valid until
-     * something proves the tree it is syncing against cannot exist.
-     *
-     * @return Whether the map has not been proven impossible.
-     */
-    [[nodiscard]] bool
+    bool
     isValid() const;
 
     // caution: otherMap must be accessed only by this function
@@ -627,51 +524,6 @@ private:
     using DeltaRef =
         std::pair<boost::intrusive_ptr<SHAMapItem const>, boost::intrusive_ptr<SHAMapItem const>>;
 
-    /**
-     * The sequence of the ledger this map references, read atomically.
-     *
-     * @return The sequence, or zero if the map references no ledger.
-     */
-    [[nodiscard]] std::uint32_t
-    ledgerSeq() const;
-
-    /**
-     * The current state, read atomically.
-     *
-     * Orders state_ alone. The tree's nodes carry no ordering guarantees.
-     *
-     * @return The state as of the call, which a concurrent walk may already
-     *         have moved past.
-     */
-    [[nodiscard]] SHAMapState
-    state() const;
-
-    /**
-     * Record that the map is provably not the one it claims to be.
-     *
-     * Private because only the map itself can prove that, from a node that
-     * contradicts the hashes it is syncing against. Cannot fail, since
-     * Invalid outranks every other state; see trySetState().
-     */
-    void
-    setInvalid();
-
-    /**
-     * Move the map to a new state, atomically.
-     *
-     * With clearSynching(), the only writer of state_ past construction, so
-     * the order between the states lives in one place: Invalid outranks all
-     * of them and is always stored, while every other transition is refused
-     * once the map is Invalid, which is what makes that verdict terminal.
-     * clearSynching() is narrower and moves only Synching.
-     *
-     * @param desired The state to move to.
-     * @return false if the map is Invalid and the requested state is not,
-     *         leaving it unchanged; true otherwise.
-     */
-    bool
-    trySetState(SHAMapState desired);
-
     // tree node cache operations
     SHAMapTreeNodePtr
     cacheLookup(SHAMapHash const& hash) const;
@@ -887,120 +739,46 @@ private:
 };
 
 inline void
-SHAMap::setFull(std::uint32_t ledgerSeq)
+SHAMap::setFull()
 {
-    ledgerSeq_.store(ledgerSeq, std::memory_order_relaxed);
-    full_.store(true, std::memory_order_release);
+    full_ = true;
 }
 
 inline void
 SHAMap::setLedgerSeq(std::uint32_t lseq)
 {
-    ledgerSeq_.store(lseq, std::memory_order_relaxed);
+    ledgerSeq_ = lseq;
 }
 
-inline std::uint32_t
-SHAMap::ledgerSeq() const
-{
-    return ledgerSeq_.load(std::memory_order_relaxed);
-}
-
-inline SHAMapState
-SHAMap::state() const
-{
-    return state_.load(std::memory_order_acquire);
-}
-
-inline bool
-SHAMap::trySetState(SHAMapState desired)
-{
-    // Invalid is stored outright: a walk reaching that verdict has to win against a thread
-    // settling the map.
-    if (desired == SHAMapState::Invalid)
-    {
-        state_.store(SHAMapState::Invalid, std::memory_order_release);
-        return true;
-    }
-
-    // A failed exchange both reports the state and refreshes expected, so no load is needed
-    // ahead of the loop.
-    auto expected = SHAMapState::Modifying;
-    while (expected != SHAMapState::Invalid)
-    {
-        if (state_.compare_exchange_weak(
-                expected, desired, std::memory_order_acq_rel, std::memory_order_acquire))
-        {
-            return true;
-        }
-    }
-    return false;
-}
-
-inline bool
+inline void
 SHAMap::setImmutable()
 {
-    SOMETIMES(!isValid(), "xrpl::SHAMap::setImmutable : map is invalid");
-    return trySetState(SHAMapState::Immutable);
+    XRPL_ASSERT(state_ != SHAMapState::Invalid, "xrpl::SHAMap::setImmutable : state is valid");
+    state_ = SHAMapState::Immutable;
 }
 
 inline bool
 SHAMap::isSynching() const
 {
-    return state() == SHAMapState::Synching;
-}
-
-inline bool
-SHAMap::isImmutable() const
-{
-    return state() == SHAMapState::Immutable;
+    return state_ == SHAMapState::Synching;
 }
 
 inline void
 SHAMap::setSynching()
 {
-    // Guarded, so this is not a way out of Invalid.
-    if (!trySetState(SHAMapState::Synching))
-    {
-        // Only ever called on a freshly constructed map.
-        // LCOV_EXCL_START
-        UNREACHABLE("xrpl::SHAMap::setSynching : map is invalid");
-        // LCOV_EXCL_STOP
-    }
+    state_ = SHAMapState::Synching;
 }
 
 inline void
 SHAMap::clearSynching()
 {
-    // Only Synching moves. A walk can end after the ledger settled, and then the map stays
-    // Immutable; a Modifying map has nothing to clear; an invalid map stays invalid. Only that
-    // last refusal is logged, since a concurrent walk is what produces it.
-    auto expected = SHAMapState::Synching;
-    if (state_.compare_exchange_strong(
-            expected, SHAMapState::Modifying, std::memory_order_acq_rel, std::memory_order_acquire))
-    {
-        return;
-    }
-
-    bool const invalid = expected == SHAMapState::Invalid;
-    SOMETIMES(invalid, "xrpl::SHAMap::clearSynching : map is invalid");
-    if (invalid)
-    {
-        JLOG(journal_.warn()) << "Refused to clear synching on an invalid map, root hash "
-                              << root_->getHash();
-    }
+    state_ = SHAMapState::Modifying;
 }
 
 inline bool
 SHAMap::isValid() const
 {
-    return state() != SHAMapState::Invalid;
-}
-
-inline void
-SHAMap::setInvalid()
-{
-    // Through trySetState() like every other transition, so state_ has one writer funnel.
-    trySetState(SHAMapState::Invalid);
+    return state_ != SHAMapState::Invalid;
 }
 
 inline void

include/xrpl/shamap/SHAMapInnerNode.h

@@ -31,19 +31,7 @@ private:
      */
     TaggedPointer hashesAndChildren_;
 
-    // Pin that wrapping fullBelowGen_ in an atomic keeps the packed layout, and that the load
-    // isFullBelow() does once per node of every walk stays lock-free.
-    static_assert(std::atomic<std::uint32_t>::is_always_lock_free);
-    static_assert(sizeof(std::atomic<std::uint32_t>) == sizeof(std::uint32_t));
-    static_assert(alignof(std::atomic<std::uint32_t>) == alignof(std::uint32_t));
-
-    /**
-     * Written from more than one thread, since canonicalization shares a node
-     * between maps and a walk can run with the acquisition lock released (see
-     * SHAMap::state_). Relaxed both ways, since a generation is only compared
-     * for equality and the children it vouches for are published through lock_.
-     */
-    std::atomic<std::uint32_t> fullBelowGen_ = 0;
+    std::uint32_t fullBelowGen_ = 0;
     std::uint16_t isBranch_ = 0;
 
     /**
@@ -216,13 +204,13 @@ SHAMapInnerNode::getBranchCount() const
 inline bool
 SHAMapInnerNode::isFullBelow(std::uint32_t generation) const
 {
-    return fullBelowGen_.load(std::memory_order_relaxed) == generation;
+    return fullBelowGen_ == generation;
 }
 
 inline void
 SHAMapInnerNode::setFullBelowGen(std::uint32_t gen)
 {
-    fullBelowGen_.store(gen, std::memory_order_relaxed);
+    fullBelowGen_ = gen;
 }
 
 }  // namespace xrpl

include/xrpl/tx/Transactor.h

@@ -375,22 +375,6 @@ public:
     /////////////////////////////////////////////////////
 
     // Interface used by AccountDelete
-    /**
-     * This method removes one Ticket ledger-object from the ledger. AccountDelete uses it to
-     * clean up Ticket objects en masse.
-     *
-     * This method reduces the TicketCount and the OwnerCount of the Owner AccountRoot object. If
-     * a TransactionProposal reserved this Ticket, that proposal is deleted as well: once the
-     * Ticket is gone, its proposed transaction can never be applied (tefNO_TICKET).
-     *
-     * @param view         the apply view for making changes.
-     * @param account      the account which owns the Ticket object.
-     * @param ticketIndex  ticketIndex is used to construct the ledger-entry ID of Ticket object.
-     * @param j            the journal reference used to log messages.
-     *
-     * @return the final TER after all invariant checks. `tefBAD_LEDGER` is returned if Ticket,
-     * Owner AccountRoot is not found in the apply-view ledger.
-     */
     static TER
     ticketDelete(
         ApplyView& view,

include/xrpl/tx/invariants/CosignerInvariant.h

@@ -1,52 +0,0 @@
-#pragma once
-
-#include <xrpl/basics/base_uint.h>
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/protocol/Keylet.h>
-#include <xrpl/protocol/STLedgerEntry.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/XRPAmount.h>
-
-#include <cstdint>
-#include <set>
-#include <vector>
-
-namespace xrpl {
-
-class ReadView;
-
-/**
- * @brief Invariants for TransactionProposal ledger entries.
- *
- * - Only transaction types implementing proposal lifecycle operations may
- *   create or modify proposals, and a failed one leaves no proposal effect.
- * - A proposal is deleted only by TransactionProposalCancel or together with
- *   the Ticket it is keyed to, and a deleted Ticket takes the proposal keyed
- *   to it along.
- * - Collected signer arrays remain sorted, unique, and bounded.
- */
-class ValidTransactionProposal
-{
-    // The Ticket each deleted proposal was keyed to; a proposal may go with
-    // its Ticket, or by Cancel, and no other way.
-    std::vector<uint256> ticketsOfDeletedProposals_;
-    // The proposal each deleted Ticket was keyed to, whether or not one
-    // existed; none may survive its Ticket.
-    std::vector<Keylet> proposalsOfDeletedTickets_;
-    std::set<uint256> deletedTickets_;
-    std::uint32_t created_ = 0;
-    std::uint32_t modified_ = 0;
-    std::uint32_t deleted_ = 0;
-    bool invalidSignerArrays_ = false;
-
-public:
-    void
-    visitEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after);
-
-    [[nodiscard]] bool
-    finalize(STTx const& tx, TER result, XRPAmount, ReadView const& view, beast::Journal const& j)
-        const;
-};
-
-}  // namespace xrpl

include/xrpl/tx/invariants/InvariantCheck.h

@@ -1,15 +1,12 @@
 #pragma once
 
-#include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/ledger/ReadView.h>
-#include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/XRPAmount.h>
 #include <xrpl/tx/invariants/AMMInvariant.h>
-#include <xrpl/tx/invariants/CosignerInvariant.h>
 #include <xrpl/tx/invariants/DirectoryInvariant.h>
 #include <xrpl/tx/invariants/FreezeInvariant.h>
 #include <xrpl/tx/invariants/LoanBrokerInvariant.h>
@@ -24,7 +21,6 @@
 #include <boost/multiprecision/cpp_int.hpp>
 
 #include <cstdint>
-#include <map>
 #include <set>
 #include <string>
 #include <tuple>
@@ -367,27 +363,11 @@ public:
  * unique to pseudo-accounts. Check that all pseudo-accounts are following the
  * rules, and that only pseudo-accounts look like pseudo-accounts.
  *
- * Post-fixCleanup3_5_0, a pseudo-account also owns only entries that belong
- * to its own AMM, Vault or LoanBroker:
- * - AMM: its AMM entry, its holdings of the two pool assets, and the trust
- *   lines of its LP token,
- * - Vault: its share MPTokenIssuance, its holding of the vault asset, and the
- *   LoanBrokers operating on this vault,
- * - LoanBroker: its Loans and its holding of the vault asset (the cover).
- *
- * A pseudo-account cannot sign transactions, so it could never accept or
- * remove any other object linked into its owner directory. Such an object
- * would pin the directory and block deletion of the owning object.
  */
 class ValidPseudoAccounts
 {
     std::vector<std::string> errors_;
 
-    // Entries newly linked into owner directories, keyed by the directory
-    // owner. Whether an owner is a pseudo-account is decided in finalize,
-    // where the view is available.
-    std::map<AccountID, std::vector<uint256>> ownerDirAdditions_;
-
 public:
     void
     visitEntry(bool, SLE::ConstRef, SLE::ConstRef);
@@ -484,7 +464,6 @@ using InvariantChecks = std::tuple<
     ValidAmounts,
     ValidMPTTransfer,
     ObjectHasPseudoAccount,
-    ValidTransactionProposal,
     SponsorshipOwnerCountsMatch,
     SponsorshipAccountCountMatchesField>;
 

include/xrpl/tx/invariants/VaultInvariant.h

@@ -8,7 +8,6 @@
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Asset.h>
 #include <xrpl/protocol/MPTIssue.h>
-#include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/STTx.h>
@@ -30,7 +29,7 @@ namespace xrpl {
  * - vault must have MPTokenIssuance for shares
  * - vault without shares outstanding must have no shares
  * - loss unrealized does not exceed the difference between assets total and
- *   assets available (Legacy/CashBasis), or AssetsDeployed (FixedPrecision)
+ *   assets available
  * - assets available do not exceed assets total
  * - vault deposit increases assets and share issuance, and adds to:
  *   total assets, assets available, shares outstanding
@@ -47,14 +46,6 @@ namespace xrpl {
  * - vault withdrawal may not succeed when the vault phase is Investment
  * - closed-ended loan origination (ttLOAN_SET) may only succeed when the
  *   vault phase is Investment
- * - FixedPrecision only: AssetsDeployed is non-negative and exactly
- *   representable at the asset's precision; AssetsDeployed changes only for
- *   ttLOAN_SET, ttLOAN_PAY and ttLOAN_MANAGE; AssetsDeployed is zero right
- *   after ttVAULT_CREATE and whenever shares outstanding return to zero; the
- *   stored AssetsTotal cache equals AssetsAvailable + AssetsDeployed, rounded
- *   Downward to the asset's precision
- * - FixedPrecision only: YieldUnrealized is non-negative; YieldUnrealized
- *   changes only for ttLOAN_SET, ttLOAN_PAY and ttLOAN_MANAGE
  *
  * Immutability of VaultKind, SubscriptionDate and RedemptionDate is enforced
  * by NoModifiedUnmodifiableFields (see InvariantCheck.cpp). From
@@ -77,9 +68,6 @@ class ValidVault
         Number assetsAvailable = 0;
         Number assetsMaximum = 0;
         Number lossUnrealized = 0;
-        Number assetsDeployed = 0;
-        Number yieldUnrealized = 0;
-        VaultVersion version = VaultVersion::Legacy;
         std::optional<std::uint8_t> vaultKind;
         std::optional<std::uint32_t> subscriptionDate;
         std::optional<std::uint32_t> redemptionDate;
@@ -229,39 +217,6 @@ private:
     [[nodiscard]] bool
     finalizeLoanSet(ReadView const& view, beast::Journal const& j) const;
 
-    /**
-     * @brief Check that a vault's AssetsTotal and AssetsAvailable deltas add
-     *        up against the real transfer, for deposit/withdraw/clawback.
-     *
-     * Shared body of the ttVAULT_DEPOSIT, ttVAULT_WITHDRAW and
-     * ttVAULT_CLAWBACK "assets outstanding"/"assets available" add-up checks,
-     * which differ only in the rounded/exact deltas plugged in and the verb
-     * used in the log message.
-     *
-     * @param afterVault Snapshot of the vault after the transaction.
-     * @param beforeVault Snapshot of the vault before the transaction.
-     * @param vaultAsset The vault's underlying asset.
-     * @param fix340Enabled Whether fixCleanup3_4_0 is enabled.
-     * @param minScale The posterior scale computed by computeVaultMinScale.
-     * @param roundedVaultDelta The real transfer's delta, rounded to minScale.
-     * @param exactVaultDelta The real transfer's exact (unrounded) delta.
-     * @param verb The transaction name used in the log message ("deposit",
-     *             "withdrawal" or "clawback").
-     * @param j Journal for logging.
-     * @return false if either add-up check fails.
-     */
-    [[nodiscard]] static bool
-    checkTotalsAddUp(
-        Vault const& afterVault,
-        Vault const& beforeVault,
-        Asset const& vaultAsset,
-        bool fix340Enabled,
-        std::int32_t minScale,
-        Number const& roundedVaultDelta,
-        Number const& exactVaultDelta,
-        char const* verb,
-        beast::Journal const& j);
-
 public:
     // Compute the coarsest scale required to represent all numbers
     [[nodiscard]] static std::int32_t

include/xrpl/tx/paths/detail/StrandFlow.h

@@ -818,10 +818,13 @@ flow(
      *   TakerPays. We reverse pays and gets because during crossing
      *   we are taking, therefore the owner must deliver the full TakerPays and
      *   the entire TakerGets doesn't have to be spent.
+     *   Pre-fixFillOrKill amendment code fails if the entire TakerGets
+     *   is not spent. fixFillOrKill addresses this issue.
      * 2. If tfSell is also set then the owner must spend the entire TakerGets
      *   even if it means obtaining more than TakerPays. Since the pays and gets
      *   are reversed, the owner must send the entire TakerGets.
      */
+    bool const fillOrKillEnabled = baseView.rules().enabled(fixFillOrKill);
 
     if (actualOut != outReq)
     {
@@ -837,9 +840,13 @@ flow(
         }
         if (!partialPayment)
         {
-            // If partialPayment is false, the caller requires full outReq (payments, or FillOrKill
-            // offers).
-            if (offerCrossing != OfferCrossing::Sell)
+            // If we're offerCrossing a !partialPayment, then we're handling tfFillOrKill.
+            // Pre-fixFillOrKill amendment:
+            //   That case is handled below; not here.
+            // fixFillOrKill amendment:
+            //   That case is handled here if tfSell is also not set; i.e, case 1.
+            if (offerCrossing == OfferCrossing::No ||
+                (fillOrKillEnabled && offerCrossing != OfferCrossing::Sell))
             {
                 return {tecPATH_PARTIAL, actualIn, actualOut, std::move(ofrsToRmOnFail)};
             }
@@ -849,10 +856,16 @@ flow(
             return {tecPATH_DRY, std::move(ofrsToRmOnFail)};
         }
     }
-    if (!partialPayment && offerCrossing == OfferCrossing::Sell)
+    if (offerCrossing != OfferCrossing::No &&
+        (!partialPayment && (!fillOrKillEnabled || offerCrossing == OfferCrossing::Sell)))
     {
         // If we're offer crossing and partialPayment is *not* true, then
-        // we're handling a FillOrKill offer.
+        // we're handling a FillOrKill offer.  In this case remainingIn must
+        // be zero (all funds must be consumed) or else we kill the offer.
+        // Pre-fixFillOrKill amendment:
+        //   Handles both cases 1. and 2.
+        // fixFillOrKill amendment:
+        //   Handles 2. 1. is handled above and falls through for tfSell.
         XRPL_ASSERT(remainingIn, "xrpl::flow : nonzero remainingIn");
         if (remainingIn && *remainingIn != beast::kZero)
             return {tecPATH_PARTIAL, actualIn, actualOut, std::move(ofrsToRmOnFail)};

include/xrpl/tx/transactors/bridge/XChainBridge.h

@@ -0,0 +1,336 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/core/ServiceRegistry.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/protocol/XRPAmount.h>
+#include <xrpl/tx/ApplyContext.h>
+#include <xrpl/tx/Transactor.h>
+
+#include <cstddef>
+#include <cstdint>
+
+namespace xrpl {
+
+constexpr size_t kXbridgeMaxAccountCreateClaims = 128;
+
+// Attach a new bridge to a door account. Once this is done, the cross-chain
+// transfer transactions may be used to transfer funds from this account.
+class XChainCreateBridge : public Transactor
+{
+public:
+    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Normal;
+
+    explicit XChainCreateBridge(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+
+    void
+    visitInvariantEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after) override;
+
+    [[nodiscard]] bool
+    finalizeInvariants(
+        STTx const& tx,
+        TER result,
+        XRPAmount fee,
+        ReadView const& view,
+        beast::Journal const& j) override;
+};
+
+class BridgeModify : public Transactor
+{
+public:
+    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Normal;
+
+    explicit BridgeModify(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+
+    void
+    visitInvariantEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after) override;
+
+    [[nodiscard]] bool
+    finalizeInvariants(
+        STTx const& tx,
+        TER result,
+        XRPAmount fee,
+        ReadView const& view,
+        beast::Journal const& j) override;
+};
+
+using XChainModifyBridge = BridgeModify;
+
+//------------------------------------------------------------------------------
+
+// Claim funds from a `XChainCommit` transaction. This is normally not needed,
+// but may be used to handle transaction failures or if the destination account
+// was not specified in the `XChainCommit` transaction. It may only be used
+// after a quorum of signatures have been sent from the witness servers.
+//
+// If the transaction succeeds in moving funds, the referenced `XChainClaimID`
+// ledger object will be destroyed. This prevents transaction replay. If the
+// transaction fails, the `XChainClaimID` will not be destroyed and the
+// transaction may be re-run with different parameters.
+class XChainClaim : public Transactor
+{
+public:
+    // Blocker since we cannot accurately calculate the consequences
+    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Blocker;
+
+    explicit XChainClaim(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+
+    void
+    visitInvariantEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after) override;
+
+    [[nodiscard]] bool
+    finalizeInvariants(
+        STTx const& tx,
+        TER result,
+        XRPAmount fee,
+        ReadView const& view,
+        beast::Journal const& j) override;
+};
+
+//------------------------------------------------------------------------------
+
+// Put assets into trust on the locking-chain so they may be wrapped on the
+// issuing-chain, or return wrapped assets on the issuing-chain so they can be
+// unlocked on the locking-chain. The second step in a cross-chain transfer.
+class XChainCommit : public Transactor
+{
+public:
+    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Custom;
+
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
+    explicit XChainCommit(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+
+    void
+    visitInvariantEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after) override;
+
+    [[nodiscard]] bool
+    finalizeInvariants(
+        STTx const& tx,
+        TER result,
+        XRPAmount fee,
+        ReadView const& view,
+        beast::Journal const& j) override;
+};
+
+//------------------------------------------------------------------------------
+
+// Create a new claim id owned by the account. This is the first step in a
+// cross-chain transfer. The claim id must be created on the destination chain
+// before the `XChainCommit` transaction (which must reference this number) can
+// be sent on the source chain. The account that will send the `XChainCommit` on
+// the source chain must be specified in this transaction (see note on the
+// `SourceAccount` field in the `XChainClaimID` ledger object for
+// justification). The actual sequence number must be retrieved from a validated
+// ledger.
+class XChainCreateClaimID : public Transactor
+{
+public:
+    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Normal;
+
+    explicit XChainCreateClaimID(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+
+    void
+    visitInvariantEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after) override;
+
+    [[nodiscard]] bool
+    finalizeInvariants(
+        STTx const& tx,
+        TER result,
+        XRPAmount fee,
+        ReadView const& view,
+        beast::Journal const& j) override;
+};
+
+//------------------------------------------------------------------------------
+
+// Provide attestations from a witness server attesting to events on
+// the other chain. The signatures must be from one of the keys on the door's
+// signer's list at the time the signature was provided. However, if the
+// signature list changes between the time the signature was submitted and the
+// quorum is reached, the new signature set is used and some of the currently
+// collected signatures may be removed. Also note the reward is only sent to
+// accounts that have keys on the current list.
+class XChainAddClaimAttestation : public Transactor
+{
+public:
+    // Blocker since we cannot accurately calculate the consequences
+    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Blocker;
+
+    explicit XChainAddClaimAttestation(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+
+    void
+    visitInvariantEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after) override;
+
+    [[nodiscard]] bool
+    finalizeInvariants(
+        STTx const& tx,
+        TER result,
+        XRPAmount fee,
+        ReadView const& view,
+        beast::Journal const& j) override;
+};
+
+class XChainAddAccountCreateAttestation : public Transactor
+{
+public:
+    // Blocker since we cannot accurately calculate the consequences
+    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Blocker;
+
+    explicit XChainAddAccountCreateAttestation(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+
+    void
+    visitInvariantEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after) override;
+
+    [[nodiscard]] bool
+    finalizeInvariants(
+        STTx const& tx,
+        TER result,
+        XRPAmount fee,
+        ReadView const& view,
+        beast::Journal const& j) override;
+};
+
+//------------------------------------------------------------------------------
+
+// This is a special transaction used for creating accounts through a
+// cross-chain transfer. A normal cross-chain transfer requires a "chain claim
+// id" (which requires an existing account on the destination chain). One
+// purpose of the "chain claim id" is to prevent transaction replay. For this
+// transaction, we use a different mechanism: the accounts must be claimed on
+// the destination chain in the same order that the `XChainCreateAccountCommit`
+// transactions occurred on the source chain.
+//
+// This transaction can only be used for XRP to XRP bridges.
+//
+// IMPORTANT: This transaction should only be enabled if the witness
+// attestations will be reliably delivered to the destination chain. If the
+// signatures are not delivered (for example, the chain relies on user wallets
+// to collect signatures) then account creation would be blocked for all
+// transactions that happened after the one waiting on attestations. This could
+// be used maliciously. To disable this transaction on XRP to XRP bridges, the
+// bridge's `MinAccountCreateAmount` should not be present.
+//
+// Note: If this account already exists, the XRP is transferred to the existing
+// account. However, note that unlike the `XChainCommit` transaction, there is
+// no error handling mechanism. If the claim transaction fails, there is no
+// mechanism for refunds. The funds are permanently lost. This transaction
+// should still only be used for account creation.
+class XChainCreateAccountCommit : public Transactor
+{
+public:
+    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Normal;
+
+    explicit XChainCreateAccountCommit(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+
+    void
+    visitInvariantEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after) override;
+
+    [[nodiscard]] bool
+    finalizeInvariants(
+        STTx const& tx,
+        TER result,
+        XRPAmount fee,
+        ReadView const& view,
+        beast::Journal const& j) override;
+};
+
+using XChainAccountCreateCommit = XChainCreateAccountCommit;
+
+//------------------------------------------------------------------------------
+
+}  // namespace xrpl

include/xrpl/tx/transactors/escrow/EscrowCreate.h

@@ -20,14 +20,11 @@ public:
     {
     }
 
-    static bool
-    checkExtraFeatures(PreflightContext const& ctx);
-
     static TxConsequences
     makeTxConsequences(PreflightContext const& ctx);
 
-    static XRPAmount
-    calculateBaseFee(ReadView const& view, STTx const& tx);
+    static bool
+    checkExtraFeatures(PreflightContext const& ctx);
 
     static NotTEC
     preflight(PreflightContext const& ctx);

include/xrpl/tx/transactors/lending/LoanManage.h

@@ -5,7 +5,6 @@
 #include <xrpl/ledger/ApplyView.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/Asset.h>
-#include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/XRPAmount.h>
@@ -46,29 +45,9 @@ public:
         SLE::Ref loanSle,
         SLE::Ref brokerSle,
         SLE::Ref vaultSle,
+        Asset const& vaultAsset,
         beast::Journal j);
 
-    /**
-     * @brief Compute the First-Loss Capital cover amount for a defaulted Loan on a FixedPrecision
-     * Vault, capped at the LoanBroker's CoverAvailable and floored so that AssetsAvailable + cover
-     * is exactly on its posterior grid.
-     *
-     * The LoanBroker absorbs the rounding. When CoverAvailable - cover needs finer digits than the
-     * broker's posterior grid, it rounds to nearest, as the broker's trust line does, so
-     * CoverAvailable can move by up to half a posterior ulp more or less than the cover. When the
-     * two grids differ, no cover is exact on both sides; the Vault side is kept exact.
-     *
-     * The one exception: when AssetsAvailable has digits finer than the 16-digit cover can carry,
-     * no cover cancels them, and the balance writer rounds AssetsAvailable + cover to nearest,
-     * by at most half a posterior ulp. VaultDeposit and LoanPay credits have the same limit.
-     * @param loanSle The Loan being defaulted.
-     * @param brokerSle The Loan's LoanBroker.
-     * @param vaultSle The LoanBroker's Vault.
-     * @return The cover amount, in the Vault's Asset.
-     */
-    static STAmount
-    calculateDefaultCover(SLE::Ref loanSle, SLE::Ref brokerSle, SLE::Ref vaultSle);
-
     /**
      * Helper function that might be needed by other transactors
      */

include/xrpl/tx/transactors/proposal/TransactionProposalCancel.h

@@ -1,44 +0,0 @@
-#pragma once
-
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/ledger/ReadView.h>
-#include <xrpl/protocol/STLedgerEntry.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/XRPAmount.h>
-#include <xrpl/tx/ApplyContext.h>
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class TransactionProposalCancel : public Transactor
-{
-public:
-    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Normal;
-
-    explicit TransactionProposalCancel(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-
-    void
-    visitInvariantEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after) override;
-
-    [[nodiscard]] bool
-    finalizeInvariants(
-        STTx const& tx,
-        TER result,
-        XRPAmount fee,
-        ReadView const& view,
-        beast::Journal const& j) override;
-};
-
-}  // namespace xrpl

include/xrpl/tx/transactors/system/Change.h

@@ -52,13 +52,6 @@ private:
     TER
     applyFee();
 
-    /**
-     * Write the default Feature Extension fee settings into FeeSettings on
-     * `featureSmartEscrow` activation.
-     */
-    void
-    initializeVMFees();
-
     TER
     applyUNLModify();
 };

src/libxrpl/json/json_value.cpp

@@ -15,6 +15,7 @@
 #include <cstring>
 #include <limits>
 #include <string>
+#include <string_view>
 #include <utility>
 
 namespace json {
@@ -241,10 +242,14 @@ Value::Value(xrpl::Number const& value) : type_(ValueType::String), allocated_(t
     value_.stringVal = valueAllocator()->duplicateStringValue(tmp.c_str(), tmp.length());
 }
 
-Value::Value(std::string const& value) : type_(ValueType::String), allocated_(true)
+Value::Value(std::string const& value) : Value(std::string_view{value})
 {
-    value_.stringVal =
-        valueAllocator()->duplicateStringValue(value.c_str(), (unsigned int)value.length());
+}
+
+Value::Value(std::string_view value) : type_(ValueType::String), allocated_(true)
+{
+    value_.stringVal = valueAllocator()->duplicateStringValue(
+        value.data(), static_cast<unsigned int>(value.length()));
 }
 
 Value::Value(StaticString const& value) : type_(ValueType::String)
@@ -1034,7 +1039,8 @@ Value::removeMember(char const* key)
     if (it == value_.mapVal->end())
         return kNull;
 
-    Value old(it->second);
+    // The entry is erased on the next line, so nothing observes what the move leaves behind.
+    Value old(std::move(it->second));
     value_.mapVal->erase(it);
     return old;
 }

src/libxrpl/ledger/Ledger.cpp

@@ -200,23 +200,11 @@ Ledger::Ledger(
                 sle->at(sfReserveIncrement) = *f;
             sle->at(sfReferenceFeeUnits) = kFeeUnitsDeprecated;
         }
-        if (std::ranges::find(amendments, featureSmartEscrow) != amendments.end())
-        {
-            sle->at(sfGasLimit) = fees.gasLimit;
-            sle->at(sfBytecodeSizeLimit) = fees.bytecodeSizeLimit;
-            sle->at(sfGasPrice) = fees.gasPrice;
-        }
         rawInsert(sle);
     }
 
     stateMap_.flushDirty(NodeObjectType::AccountNode);
-    // Built locally. See Ledger::setImmutable().
-    if (!setImmutable())
-    {
-        // LCOV_EXCL_START
-        logicError("Ledger::Ledger(CreateGenesisT, ...): genesis ledger map is invalid");
-        // LCOV_EXCL_STOP
-    }
+    setImmutable();
 }
 
 Ledger::Ledger(
@@ -227,7 +215,7 @@ Ledger::Ledger(
     Fees const& fees,
     Family& family,
     beast::Journal j)
-    : immutable_(false)
+    : immutable_(true)
     , txMap_(SHAMapType::TRANSACTION, info.txHash, family)
     , stateMap_(SHAMapType::STATE, info.accountHash, family)
     , fees_(fees)
@@ -250,20 +238,8 @@ Ledger::Ledger(
         JLOG(j.warn()) << "Don't have state data root for ledger" << header_.seq;
     }
 
-    // Loaded locally. See Ledger::setImmutable().
-    if (setMapsImmutable())
-    {
-        immutable_ = true;
-    }
-    else
-    {
-        // LCOV_EXCL_START
-        JLOG(j.error()) << "Invalid map for ledger " << header_.seq;
-        UNREACHABLE("xrpl::Ledger::Ledger(LedgerHeader const&, ...) : map is invalid");
-        // Treat it as a damaged ledger: the code below recomputes the hash and re-acquires.
-        loaded = false;
-        // LCOV_EXCL_STOP
-    }
+    txMap_.setImmutable();
+    stateMap_.setImmutable();
 
     if (!setup())
         loaded = false;
@@ -334,50 +310,27 @@ Ledger::Ledger(
     setup();
 }
 
-bool
+void
 Ledger::setImmutable(bool rehash)
 {
-    // A map found structurally invalid during sync must never be made immutable: isValid() tests
-    // only for Invalid, and an immutable ledger is treated as persistable. Asked before anything is
-    // written, so a refusal leaves the header exactly as it was rather than half relabeled.
-    if (!mapsValid())
-        return false;
-
-    // Read here but written to the header below, once the maps are settled: getHash() can unshare a
-    // dirty tree, so it has to run while the map is still mutable, while a write to the header must
-    // wait until both maps have made it. Skipped once the ledger is immutable, since its maps can
-    // no longer change.
-    bool const deriveMapHashes = !immutable_ && rehash;
-    UInt256 const txHash = deriveMapHashes ? txMap_.getHash().asUInt256() : UInt256{};
-    UInt256 const accountHash = deriveMapHashes ? stateMap_.getHash().asUInt256() : UInt256{};
-
-    // Both were valid at the check above, but a concurrent walk can invalidate one in between (see
-    // SHAMap::state_), so the result is checked. setInvalid() outranks Immutable and can land
-    // after both maps have been settled, so this narrows the window it guards.
-    bool const bothImmutable = setMapsImmutable();
-    SOMETIMES(!bothImmutable, "xrpl::Ledger::setImmutable : map invalidated while going immutable");
-    if (!bothImmutable)
-        return false;
-
-    // Written only now, so losing the race above leaves the header describing what the ledger was
-    // built from rather than a map that has since been abandoned. Forced rather than conditional,
-    // since this is the only place the hash transitions to valid.
-    if (deriveMapHashes)
+    // Force update, since this is the only
+    // place the hash transitions to valid
+    if (!immutable_ && rehash)
     {
-        header_.txHash = txHash;
-        header_.accountHash = accountHash;
+        header_.txHash = txMap_.getHash().asUInt256();
+        header_.accountHash = stateMap_.getHash().asUInt256();
     }
 
     if (rehash)
         header_.hash = calculateLedgerHash(header_);
 
-    // Set last, so isImmutable() reports only a ledger whose maps are both immutable.
     immutable_ = true;
+    txMap_.setImmutable();
+    stateMap_.setImmutable();
     setup();
-    return true;
 }
 
-bool
+void
 Ledger::setAccepted(
     NetClock::time_point closeTime,
     NetClock::duration closeResolution,
@@ -389,17 +342,7 @@ Ledger::setAccepted(
     header_.closeTime = closeTime;
     header_.closeTimeResolution = closeResolution;
     header_.closeFlags = correctCloseTime ? 0 : kSLcfNoConsensusTime;
-    // Built locally. See Ledger::setImmutable().
-    if (!setImmutable())
-    {
-        // LCOV_EXCL_START
-        JLOG(j_.error()) << "Invalid map for accepted ledger " << header_.seq;
-        UNREACHABLE("xrpl::Ledger::setAccepted : map is invalid");
-        return false;
-        // LCOV_EXCL_STOP
-    }
-
-    return true;
+    setImmutable();
 }
 
 bool
@@ -623,7 +566,6 @@ Ledger::setup()
         {
             bool oldFees = false;
             bool newFees = false;
-            bool extensionFees = false;
             {
                 auto const baseFee = sle->at(~sfBaseFee);
                 auto const reserveBase = sle->at(~sfReserveBase);
@@ -658,20 +600,6 @@ Ledger::setup()
                 assign(fees_.increment, reserveIncrementXRP);
                 newFees = baseFeeXRP || reserveBaseXRP || reserveIncrementXRP;
             }
-            {
-                auto const gasLimit = sle->at(~sfGasLimit);
-                auto const bytecodeSizeLimit = sle->at(~sfBytecodeSizeLimit);
-                auto const gasPrice = sle->at(~sfGasPrice);
-
-                // An absent field resolves to the protocol constant.
-                if (rules_.enabled(featureSmartEscrow))
-                {
-                    fees_.gasLimit = gasLimit.value_or(kDefaultGasLimit);
-                    fees_.bytecodeSizeLimit = bytecodeSizeLimit.value_or(kDefaultBytecodeSizeLimit);
-                    fees_.gasPrice = gasPrice.value_or(kDefaultGasPrice);
-                }
-                extensionFees = gasLimit || bytecodeSizeLimit || gasPrice;
-            }
             if (oldFees && newFees)
             {
                 // Should be all of one or the other, but not both
@@ -682,12 +610,6 @@ Ledger::setup()
                 // Can't populate the new fees before the amendment is enabled
                 ret = false;
             }
-            if (!rules_.enabled(featureSmartEscrow) && extensionFees)
-            {
-                // Can't populate the extension fees before the amendment is
-                // enabled
-                ret = false;
-            }
         }
     }
     catch (SHAMapMissingNode const&)