Xls 68 sponsored fees reserves updated

V7_MIGRATION.md

@@ -0,0 +1,191 @@
+# Version 6 to Version 7 Migration Guide
+
+This guide outlines the breaking changes between v6.x.x and v7.0.0 and provides an upgrade path for applications using
+xrpl4j.
+
+## Overview
+
+Version 7.0.0 introduces several breaking changes:
+
+1. **Issue Model Refactor** — `Issue` has been refactored from a concrete immutable into a polymorphic interface with
+   three subtypes (`XrpIssue`, `IouIssue`, `MptIssue`) to support the
+   [Single Asset Vault](https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0065-single-asset-vault) amendment.
+2. **Transaction Signing API Refactor** — `SignatureUtils.addSignatureToTransaction()` and
+   `SignatureUtils.addMultiSignaturesToTransaction()` have been removed. Transaction signing now uses Immutables-generated
+   `withTransactionSignature()` and `withSigners()` methods on `Transaction`, and validation has moved to `@Check`
+   methods on `SingleSignedTransaction` and `MultiSignedTransaction`.
+
+## Breaking Changes
+
+### 1. Issue Model
+
+#### Issue is now an interface
+
+`Issue` was previously an `@Value.Immutable` with a `builder()` method, a `currency()` field, and an optional
+`issuer()` field. It is now a plain interface with three concrete implementations: `XrpIssue`, `IouIssue`, and
+`MptIssue`. The `Issue` interface provides `handle()` and `map()` methods for type-safe polymorphic dispatch across the
+three subtypes.
+
+#### Issue.builder() removed
+
+`Issue.builder()` and `ImmutableIssue.Builder` no longer exist. Use the concrete subtype builders instead.
+
+**Migration:**
+
+```java
+// Before (v6.x.x): XRP Issue
+Issue xrp = Issue.builder().currency("XRP").build();
+
+// After (v7.0.0): XRP Issue
+Issue xrp = Issue.XRP; // or XrpIssue.XRP
+
+// Before (v6.x.x): IOU Issue
+Issue usd = Issue.builder()
+    .currency("USD")
+    .issuer(issuerAddress)
+    .build();
+
+// After (v7.0.0): IOU Issue
+Issue usd = IouIssue.builder()
+    .currency("USD")
+    .issuer(issuerAddress)
+    .build();
+```
+
+You can now also create MPT issues:
+
+```java
+// New in v7.0.0: MPT Issue
+Issue mpt = MptIssue.builder()
+    .mptIssuanceId(mptIssuanceId)
+    .build();
+```
+
+#### Issue.currency() and Issue.issuer() removed
+
+The `currency()` and `issuer()` accessors are no longer on the `Issue` interface. They have moved to the concrete
+subtypes where they apply:
+
+- `XrpIssue.currency()` — always returns `"XRP"`
+- `IouIssue.currency()` — returns the currency code
+- `IouIssue.issuer()` — returns the issuer `Address`
+- `MptIssue.mptIssuanceId()` — returns the `MpTokenIssuanceId`
+
+**Migration:**
+
+Use the `handle()` or `map()` methods to work with `Issue` instances polymorphically. For example, in v6.x.x you could
+access currency and issuer directly from an `AmmObject`:
+
+```java
+// Before (v6.x.x)
+Issue issue = ammObject.asset();
+String currency = issue.currency();
+Optional<Address> issuer = issue.issuer();
+```
+
+In v7.0.0, objects like `VaultObject` can hold any asset type (XRP, IOU, or MPT). Use `handle()` to dispatch based on
+the concrete type:
+
+```java
+// After (v7.0.0)
+Issue issue = vaultObject.asset();
+issue.handle(
+  // Handle XRP
+  xrpIssue -> {
+    String currency = xrpIssue.currency(); // "XRP"
+  },
+  // Handle IOU
+  iouIssue -> {
+    String currency = iouIssue.currency();
+    Address issuer = iouIssue.issuer();
+  },
+  // Handle MPT
+  mptIssue -> {
+    MpTokenIssuanceId issuanceId = mptIssue.mptIssuanceId();
+  }
+);
+```
+
+Or use `map()` to transform an `Issue` into a value:
+
+```java
+Issue issue = vaultObject.asset();
+String description = issue.map(
+  xrpIssue -> "XRP",
+  iouIssue -> iouIssue.currency() + "/" + iouIssue.issuer(),
+  mptIssue -> "MPT:" + mptIssue.mptIssuanceId()
+);
+```
+
+#### JSON Serialization
+
+JSON serialization and deserialization remain compatible. The `IssueDeserializer` automatically selects the correct
+subtype based on the JSON structure:
+
+- `{"currency": "XRP"}` → `XrpIssue`
+- `{"currency": "USD", "issuer": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn"}` → `IouIssue`
+- `{"mpt_issuance_id": "00000001A407AF5856CFF3379945D823561023E8E5CED9C9"}` → `MptIssue`
+
+### 2. Transaction Signing API
+
+The transaction signing internals have been refactored to eliminate per-transaction-type switch statements in
+`SignatureUtils`. This change leverages Immutables-generated builder methods on the `Transaction` interface.
+
+#### `SignatureUtils.addSignatureToTransaction()` removed
+
+This method contained a large switch statement with explicit handling for every transaction type. It has been removed.
+The signing flow now uses `Transaction.withTransactionSignature()` directly.
+
+**Migration:**
+
+If you were calling `addSignatureToTransaction()` directly (uncommon — this was primarily used internally by
+`AbstractTransactionSigner`):
+
+```java
+// Before (v6.x.x)
+SingleSignedTransaction<Payment> signed = signatureUtils.addSignatureToTransaction(payment, signature);
+
+// After (v7.0.0)
+Transaction signedTx = payment.withTransactionSignature(signature);
+SingleSignedTransaction<Payment> signed = SingleSignedTransaction.<Payment>builder()
+    .unsignedTransaction(payment)
+    .signature(signature)
+    .signedTransaction((Payment) signedTx)
+    .build();
+```
+
+#### `SignatureUtils.addMultiSignaturesToTransaction()` removed
+
+This method has also been removed. Use `Transaction.withSigners()` instead.
+
+**Migration:**
+
+```java
+// Before (v6.x.x)
+Transaction multiSigned = signatureUtils.addMultiSignaturesToTransaction(transaction, signerWrappers);
+
+// After (v7.0.0)
+Transaction multiSigned = transaction.withSigners(signerWrappers);
+```
+
+#### New `Transaction` interface methods
+
+Two new methods have been added to the `Transaction` interface. Immutables generates concrete implementations of these
+for every transaction subclass:
+
+- `Transaction withTransactionSignature(Signature signature)` — returns a copy of the transaction with the signature
+  applied.
+- `Transaction withSigners(Iterable<? extends SignerWrapper> signers)` — returns a copy of the transaction with the
+  specified signers applied.
+
+## Backward Compatibility
+
+- JSON serialization and deserialization remain compatible with the same JSON structure.
+- The `Issue.XRP` constant is still available and works the same way.
+- The `TransactionSigner.sign()` and `TransactionSigner.multiSign()` APIs are unchanged — only the internal
+  implementation has changed. If you use these high-level APIs (e.g., via `BcSignatureService`), no migration is needed
+  for signing.
+
+## Additional Resources
+
+- **XLS-0065 Specification**: https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0065-single-asset-vault

pom.xml

@@ -336,6 +336,8 @@
           <configuration>
             <source>${maven.compiler.source}</source>
             <target>${maven.compiler.target}</target>
+            <!-- Prevents annotation processor ordering issues with Immutables -->
+            <useIncrementalCompilation>false</useIncrementalCompilation>
 
             <annotationProcessorPaths>
               <path>

xrpl4j-client/src/main/java/org/xrpl/xrpl4j/client/XrplClient.java

@@ -53,6 +53,8 @@
 import org.xrpl.xrpl4j.model.client.accounts.AccountObjectsResult;
 import org.xrpl.xrpl4j.model.client.accounts.AccountOffersRequestParams;
 import org.xrpl.xrpl4j.model.client.accounts.AccountOffersResult;
+import org.xrpl.xrpl4j.model.client.accounts.AccountSponsoringRequestParams;
+import org.xrpl.xrpl4j.model.client.accounts.AccountSponsoringResult;
 import org.xrpl.xrpl4j.model.client.accounts.AccountTransactionsRequestParams;
 import org.xrpl.xrpl4j.model.client.accounts.AccountTransactionsResult;
 import org.xrpl.xrpl4j.model.client.accounts.GatewayBalancesRequestParams;
@@ -95,6 +97,8 @@
 import org.xrpl.xrpl4j.model.client.transactions.SubmitResult;
 import org.xrpl.xrpl4j.model.client.transactions.TransactionRequestParams;
 import org.xrpl.xrpl4j.model.client.transactions.TransactionResult;
+import org.xrpl.xrpl4j.model.client.vault.VaultInfoRequestParams;
+import org.xrpl.xrpl4j.model.client.vault.VaultInfoResult;
 import org.xrpl.xrpl4j.model.immutables.FluentCompareTo;
 import org.xrpl.xrpl4j.model.jackson.ObjectMapperFactory;
 import org.xrpl.xrpl4j.model.ledger.LedgerObject;
@@ -618,6 +622,31 @@ public AccountOffersResult accountOffers(AccountOffersRequestParams params) thro
     return jsonRpcClient.send(request, AccountOffersResult.class);
   }
 
+  /**
+   * Get the {@link AccountSponsoringResult} for the account specified in {@code params} by making an account_sponsoring
+   * method call.
+   *
+   * <p>This method will be marked {@link Beta} until the featureSponsorship amendment is enabled on mainnet.
+   * Its API is subject to change.</p>
+   *
+   * @param params The {@link AccountSponsoringRequestParams} to send in the request.
+   *
+   * @return The {@link AccountSponsoringResult} returned by the account_sponsoring method call.
+   *
+   * @throws JsonRpcClientErrorException If {@code jsonRpcClient} throws an error.
+   *
+   * @see "https://github.com/XRPLF/XRPL-Standards/blob/master/XLS-0068-sponsored-fees-and-reserves/README.md"
+   */
+  @Beta
+  public AccountSponsoringResult accountSponsoring(AccountSponsoringRequestParams params)
+    throws JsonRpcClientErrorException {
+    JsonRpcRequest request = JsonRpcRequest.builder()
+      .method(XrplMethods.ACCOUNT_SPONSORING)
+      .addParams(params)
+      .build();
+    return jsonRpcClient.send(request, AccountSponsoringResult.class);
+  }
+
   /**
    * Indicates whether one account is authorized to send payments directly to another.
    *
@@ -893,6 +922,27 @@ public MptHoldersResponse mptHolders(MptHoldersRequestParams params) throws Json
     return jsonRpcClient.send(request, MptHoldersResponse.class);
   }
 
+  /**
+   * Get info about a Vault by making a call to the vault_info rippled RPC method.
+   *
+   * @param params The {@link VaultInfoRequestParams} to send in the request.
+   *
+   * @return A {@link VaultInfoResult}.
+   *
+   * @throws JsonRpcClientErrorException if {@code jsonRpcClient} throws an error.
+   */
+  @Beta
+  public VaultInfoResult vaultInfo(
+    VaultInfoRequestParams params
+  ) throws JsonRpcClientErrorException {
+    JsonRpcRequest request = JsonRpcRequest.builder()
+      .method(XrplMethods.VAULT_INFO)
+      .addParams(params)
+      .build();
+
+    return jsonRpcClient.send(request, VaultInfoResult.class);
+  }
+
   public JsonRpcClient getJsonRpcClient() {
     return jsonRpcClient;
   }

xrpl4j-client/src/test/java/org/xrpl/xrpl4j/client/XrplClientTest.java

@@ -65,6 +65,8 @@
 import org.xrpl.xrpl4j.model.client.accounts.AccountObjectsResult;
 import org.xrpl.xrpl4j.model.client.accounts.AccountOffersRequestParams;
 import org.xrpl.xrpl4j.model.client.accounts.AccountOffersResult;
+import org.xrpl.xrpl4j.model.client.accounts.AccountSponsoringRequestParams;
+import org.xrpl.xrpl4j.model.client.accounts.AccountSponsoringResult;
 import org.xrpl.xrpl4j.model.client.accounts.AccountTransactionsRequestParams;
 import org.xrpl.xrpl4j.model.client.accounts.AccountTransactionsResult;
 import org.xrpl.xrpl4j.model.client.accounts.GatewayBalancesRequestParams;
@@ -107,9 +109,12 @@
 import org.xrpl.xrpl4j.model.client.transactions.SubmitResult;
 import org.xrpl.xrpl4j.model.client.transactions.TransactionRequestParams;
 import org.xrpl.xrpl4j.model.client.transactions.TransactionResult;
+import org.xrpl.xrpl4j.model.client.vault.VaultInfoRequestParams;
+import org.xrpl.xrpl4j.model.client.vault.VaultInfoResult;
 import org.xrpl.xrpl4j.model.flags.AccountRootFlags;
 import org.xrpl.xrpl4j.model.jackson.ObjectMapperFactory;
 import org.xrpl.xrpl4j.model.ledger.AccountRootObject;
+import org.xrpl.xrpl4j.model.ledger.IouIssue;
 import org.xrpl.xrpl4j.model.ledger.Issue;
 import org.xrpl.xrpl4j.model.ledger.LedgerObject;
 import org.xrpl.xrpl4j.model.transactions.Address;
@@ -955,7 +960,7 @@ void bookOffers() throws JsonRpcClientErrorException {
       .taker(Address.of("r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59"))
       .takerGets(Issue.XRP)
       .takerPays(
-        Issue.builder()
+        IouIssue.builder()
           .issuer(Address.of("rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B"))
           .currency("USD")
           .build()
@@ -990,6 +995,20 @@ public void accountLines() throws JsonRpcClientErrorException {
     assertThat(jsonRpcRequestArgumentCaptor.getValue().params().get(0)).isEqualTo(accountLinesRequestParams);
   }
 
+  @Test
+  public void accountSponsoring() throws JsonRpcClientErrorException {
+    AccountSponsoringRequestParams accountSponsoringRequestParams = AccountSponsoringRequestParams.builder()
+      .account(Address.of("rDgZZ3wyprx4ZqrGQUkquE9Fs2Xs8XBcdw"))
+      .ledgerSpecifier(LedgerSpecifier.CURRENT)
+      .build();
+    xrplClient.accountSponsoring(accountSponsoringRequestParams);
+
+    ArgumentCaptor<JsonRpcRequest> jsonRpcRequestArgumentCaptor = ArgumentCaptor.forClass(JsonRpcRequest.class);
+    verify(jsonRpcClientMock).send(jsonRpcRequestArgumentCaptor.capture(), eq(AccountSponsoringResult.class));
+    assertThat(jsonRpcRequestArgumentCaptor.getValue().method()).isEqualTo(XrplMethods.ACCOUNT_SPONSORING);
+    assertThat(jsonRpcRequestArgumentCaptor.getValue().params().get(0)).isEqualTo(accountSponsoringRequestParams);
+  }
+
   @Test
   public void channelVerify() throws JsonRpcClientErrorException {
     ChannelVerifyRequestParams channelVerifyRequestParams = ChannelVerifyRequestParams.builder()
@@ -1060,6 +1079,20 @@ void ammInfo() throws JsonRpcClientErrorException {
     assertThat(result).isEqualTo(mockResult);
   }
 
+  @Test
+  void vaultInfo() throws JsonRpcClientErrorException {
+    VaultInfoRequestParams params = mock(VaultInfoRequestParams.class);
+    JsonRpcRequest expectedRequest = JsonRpcRequest.builder()
+      .method(XrplMethods.VAULT_INFO)
+      .addParams(params)
+      .build();
+    VaultInfoResult mockResult = mock(VaultInfoResult.class);
+    when(jsonRpcClientMock.send(expectedRequest, VaultInfoResult.class)).thenReturn(mockResult);
+    VaultInfoResult result = xrplClient.vaultInfo(params);
+
+    assertThat(result).isEqualTo(mockResult);
+  }
+
   @Test
   void ledgerEntry() throws JsonRpcClientErrorException {
     LedgerEntryRequestParams<LedgerObject> params = LedgerEntryRequestParams.index(

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/codec/addresses/UnsignedByteArray.java

@@ -216,6 +216,18 @@ public UnsignedByteArray slice(int startIndex, int endIndex) {
     return new UnsignedByteArray(unsignedBytes.subList(startIndex, endIndex));
   }
 
+  /**
+   * Returns a new {@link UnsignedByteArray} with the bytes in reversed order.
+   * This is useful for converting between big-endian and little-endian byte order.
+   *
+   * @return A new {@link UnsignedByteArray} with bytes in reversed order.
+   */
+  public UnsignedByteArray reverse() {
+    List<UnsignedByte> reversed = new ArrayList<>(unsignedBytes);
+    Collections.reverse(reversed);
+    return new UnsignedByteArray(reversed);
+  }
+
   @Override
   public boolean equals(Object object) {
     if (this == object) {