XRPLF
diff --git a/‎pom.xml‎
Lines changed: 2 additions & 0 deletions b/‎pom.xml‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎xrpl4j-client/src/main/java/org/xrpl/xrpl4j/client/XrplClient.java‎
Lines changed: 27 additions & 0 deletions b/‎xrpl4j-client/src/main/java/org/xrpl/xrpl4j/client/XrplClient.java‎
Lines changed: 27 additions & 0 deletions
diff --git a/‎xrpl4j-client/src/test/java/org/xrpl/xrpl4j/client/XrplClientTest.java‎
Lines changed: 16 additions & 0 deletions b/‎xrpl4j-client/src/test/java/org/xrpl/xrpl4j/client/XrplClientTest.java‎
Lines changed: 16 additions & 0 deletions
diff --git a/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/codec/binary/types/Int32Type.java‎
Lines changed: 81 additions & 0 deletions b/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/codec/binary/types/Int32Type.java‎
Lines changed: 81 additions & 0 deletions
diff --git a/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/codec/binary/types/SerializedType.java‎
Lines changed: 1 addition & 0 deletions b/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/codec/binary/types/SerializedType.java‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/AbstractSignatureService.java‎
Lines changed: 10 additions & 0 deletions b/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/AbstractSignatureService.java‎
Lines changed: 10 additions & 0 deletions
diff --git a/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/AbstractTransactionSigner.java‎
Lines changed: 27 additions & 0 deletions b/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/AbstractTransactionSigner.java‎
Lines changed: 27 additions & 0 deletions
diff --git a/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/SignatureUtils.java‎
Lines changed: 34 additions & 0 deletions b/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/SignatureUtils.java‎
Lines changed: 34 additions & 0 deletions
diff --git a/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/TransactionSigner.java‎
Lines changed: 44 additions & 0 deletions b/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/TransactionSigner.java‎
Lines changed: 44 additions & 0 deletions
diff --git a/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/bc/BcDerivedKeySignatureService.java‎
Lines changed: 26 additions & 0 deletions b/‎xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/bc/BcDerivedKeySignatureService.java‎
Lines changed: 26 additions & 0 deletions
@@ -330,6 +330,8 @@
           <configuration>
             <source>${maven.compiler.source}</source>
             <target>${maven.compiler.target}</target>
+            <!-- Prevents annotation processor ordering issues with Immutables -->
+            <useIncrementalCompilation>false</useIncrementalCompilation>
 
             <annotationProcessorPaths>
               <path>
 
@@ -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;
@@ -620,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.
    *
 
@@ -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;
@@ -993,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()
 
@@ -0,0 +1,81 @@
+package org.xrpl.xrpl4j.codec.binary.types;
+
+/*-
+ * ========================LICENSE_START=================================
+ * xrpl4j :: binary-codec
+ * %%
+ * Copyright (C) 2020 - 2022 XRPL Foundation and its contributors
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =========================LICENSE_END==================================
+ */
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.IntNode;
+import org.xrpl.xrpl4j.codec.addresses.ByteUtils;
+import org.xrpl.xrpl4j.codec.addresses.UnsignedByteArray;
+import org.xrpl.xrpl4j.codec.binary.serdes.BinaryParser;
+
+import java.math.BigInteger;
+
+/**
+ * Codec for the XRPL Int32 type, a signed 32-bit integer encoded on the wire using two's complement, the same
+ * 4-byte-wide encoding as {@link UInt32Type}.
+ */
+public class Int32Type extends SerializedType<Int32Type> {
+
+  private static final BigInteger UINT32_MASK = BigInteger.valueOf(0xFFFFFFFFL);
+  private static final int HEX_LENGTH = 8;
+
+  /**
+   * No-args constructor, defaulting to a value of {@code 0}.
+   */
+  public Int32Type() {
+    this(0);
+  }
+
+  /**
+   * Required-args constructor.
+   *
+   * @param value The signed {@code int} value that this {@link Int32Type} should encode.
+   */
+  public Int32Type(int value) {
+    super(UnsignedByteArray.fromHex(
+      ByteUtils.padded(BigInteger.valueOf(value).and(UINT32_MASK).toString(16), HEX_LENGTH)
+    ));
+  }
+
+  private Int32Type(UnsignedByteArray bytes) {
+    super(bytes);
+  }
+
+  @Override
+  public Int32Type fromParser(BinaryParser parser) {
+    return new Int32Type(parser.read(4));
+  }
+
+  @Override
+  public Int32Type fromJson(JsonNode value) {
+    return new Int32Type(value.asInt());
+  }
+
+  @Override
+  public JsonNode toJson() {
+    String hex = toHex();
+    try {
+      return new IntNode((int) Long.parseLong(hex, 16));
+    } catch (NumberFormatException e) {
+      throw new IllegalStateException("Invalid hex value for Int32Type: " + hex, e);
+    }
+  }
+}
@@ -52,6 +52,7 @@ public abstract class SerializedType<T extends SerializedType<T>> {
       .put("Hash160", () -> new Hash160Type())
       .put("Hash192", () -> new UInt192Type())
       .put("Hash256", () -> new Hash256Type())
+      .put("Int32", () -> new Int32Type())
       .put("PathSet", () -> new PathSetType())
       .put("STArray", () -> new STArrayType())
       .put("STObject", () -> new STObjectType())
 
@@ -138,6 +138,16 @@ public Signature counterpartyMultiSign(final P privateKeyable, final LoanSet tra
     return abstractTransactionSigner.counterpartyMultiSign(privateKeyable, transaction);
   }
 
+  @Override
+  public <T extends Transaction> Signature sponsorSign(final P privateKeyable, final T transaction) {
+    return abstractTransactionSigner.sponsorSign(privateKeyable, transaction);
+  }
+
+  @Override
+  public <T extends Transaction> Signature sponsorMultiSign(final P privateKeyable, final T transaction) {
+    return abstractTransactionSigner.sponsorMultiSign(privateKeyable, transaction);
+  }
+
   @Override
   public <T extends Transaction> boolean verify(final Signer signer, final T unsignedTransaction) {
     return abstractTransactionVerifier.verify(signer, unsignedTransaction);
 
@@ -143,6 +143,33 @@ public Signature counterpartyMultiSign(final P privateKeyable, final LoanSet tra
     return this.signatureHelper(privateKeyable, signableTransactionBytes);
   }
 
+  @Override
+  public <T extends Transaction> Signature sponsorSign(final P privateKeyable, final T transaction) {
+    Objects.requireNonNull(privateKeyable);
+    Objects.requireNonNull(transaction);
+
+    // Per the rippled implementation of the Sponsorship amendment, sponsor single-signing uses the same
+    // HashPrefix::txSign (STX, 0x53545800) prefix and serialization as regular single-signing. Domain separation
+    // between the account-owner and sponsor roles is not required at the signing-bytes level because the resulting
+    // signatures are placed in distinct transaction fields (TxnSignature vs SponsorSignature.TxnSignature), and the
+    // account-owner and sponsor use different key pairs. So this can safely reuse the regular signing path.
+    return this.signatureHelper(privateKeyable, transaction);
+  }
+
+  @Override
+  public <T extends Transaction> Signature sponsorMultiSign(final P privateKeyable, final T transaction) {
+    Objects.requireNonNull(privateKeyable);
+    Objects.requireNonNull(transaction);
+
+    // Sponsor multi-signing preserves the first-party signer's SigningPubKey in the signed data.
+    // This differs from regular multi-signing which clears the SigningPubKey.
+    final Address address = derivePublicKey(privateKeyable).deriveAddress();
+    final UnsignedByteArray signableTransactionBytes = this.signatureUtils.toSponsorMultiSignableBytes(
+      transaction, address
+    );
+    return this.signatureHelper(privateKeyable, signableTransactionBytes);
+  }
+
   /**
    * Helper to serialize a {@link Transaction} to signable bytes and then generate a {@link Signature}.
    *
 
@@ -77,6 +77,7 @@ public SignatureUtils(final ObjectMapper objectMapper, final XrplBinaryCodec bin
    */
   public UnsignedByteArray toSignableBytes(final Transaction transaction) {
     Objects.requireNonNull(transaction);
+
     try {
       final String unsignedJson = objectMapper.writeValueAsString(transaction);
       final String unsignedBinaryHex = binaryCodec.encodeForSigning(unsignedJson);
@@ -217,4 +218,37 @@ public UnsignedByteArray toMultiSignableInnerBytes(
     Objects.requireNonNull(nestedSignerAddress);
     return binaryCodec.encodeForBatchInnerMultiSigning(batch, batchSignerAddress, nestedSignerAddress);
   }
+
+  /**
+   * Helper method to convert a {@link Transaction} into bytes that can be multi-signed by a sponsor.
+   *
+   * <p>Unlike {@link #toMultiSignableBytes(Transaction, Address)}, this method preserves the existing
+   * {@code SigningPubKey} field in the encoded bytes. This is necessary when a sponsor multi-signs a transaction
+   * where the first-party signer's {@code SigningPubKey} must remain intact in the signed data.</p>
+   *
+   * <p>This method will be marked {@link Beta} until the featureSponsorship amendment is enabled on mainnet.
+   * Its API is subject to change.</p>
+   *
+   * @param transaction   A {@link Transaction} to be sponsor multi-signed.
+   * @param signerAddress The {@link Address} of the sponsor signer.
+   *
+   * @return An {@link UnsignedByteArray}.
+   */
+  @Beta
+  public UnsignedByteArray toSponsorMultiSignableBytes(final Transaction transaction, final Address signerAddress) {
+    Objects.requireNonNull(transaction);
+    Objects.requireNonNull(signerAddress);
+
+    try {
+      final String unsignedJson = objectMapper.writeValueAsString(transaction);
+      final String unsignedBinaryHex = binaryCodec.encodeForMultiSigningWithSigningPubKey(
+        unsignedJson, signerAddress.value()
+      );
+      return UnsignedByteArray.fromHex(unsignedBinaryHex);
+    } catch (JsonProcessingException e) {
+      throw new RuntimeException(e.getMessage(), e);
+    }
+  }
+
 }
+
@@ -179,6 +179,50 @@ public interface TransactionSigner<P extends PrivateKeyable> {
   @Beta
   Signature counterpartyMultiSign(P privateKeyable, LoanSet transaction);
 
+  /**
+   * Obtain a sponsor single-signature for the supplied transaction. Per rippled's Sponsorship amendment
+   * implementation, the sponsor signs the same serialized bytes (using the {@code STX} / 0x53545800 prefix) as the
+   * account-owner. Domain separation is achieved structurally: the sponsor's signature is placed into the
+   * {@link Transaction#sponsorSignature()} field rather than the transaction's {@code TxnSignature}, and the
+   * account-owner and sponsor use different key pairs.
+   *
+   * <p>This method returns only the raw {@link Signature} rather than a {@link SingleSignedTransaction}
+   * wrapper.</p>
+   *
+   * <p>This method will be marked {@link Beta} until the featureSponsorship amendment is enabled on mainnet.
+   * Its API is subject to change.</p>
+   *
+   * @param privateKeyable The {@link P} used to sign {@code transaction}.
+   * @param transaction    The {@link Transaction} to sign as the sponsor.
+   * @param <T>            The type of the transaction to be signed.
+   *
+   * @return A {@link Signature} for the sponsor.
+   */
+  @Beta
+  <T extends Transaction> Signature sponsorSign(P privateKeyable, T transaction);
+
+  /**
+   * Obtain a sponsor multi-signature for the supplied transaction. Unlike
+   * {@link #multiSign(PrivateKeyable, Transaction)}, this method does <b>not</b> clear the {@code SigningPubKey}
+   * field, preserving the first-party signer's public key in the signed data. The resulting bytes use the same
+   * multi-signing prefix ({@code SMT\0}) and the sponsor signer's account ID suffix.
+   *
+   * <p>This is necessary for sponsored transactions where the sponsor must co-sign without overwriting
+   * the transaction sender's signature. The sponsor's multi-signature is placed in the
+   * {@link Transaction#sponsorSignature()} {@code Signers} array.</p>
+   *
+   * <p>This method will be marked {@link Beta} until the featureSponsorship amendment is enabled on mainnet.
+   * Its API is subject to change.</p>
+   *
+   * @param privateKeyable The {@link P} used to sign {@code transaction}.
+   * @param transaction    The {@link Transaction} to sponsor multi-sign.
+   * @param <T>            The type of the transaction to be signed.
+   *
+   * @return A {@link Signature} for the sponsor signer.
+   */
+  @Beta
+  <T extends Transaction> Signature sponsorMultiSign(P privateKeyable, T transaction);
+
   /**
    * Obtain a signature for the supplied unsigned transaction using the supplied {@link P}.
    * <p>
 
@@ -178,6 +178,24 @@ public Signature counterpartyMultiSign(final PrivateKeyReference privateKeyRefer
     return getTransactionSigner(privateKeyReference).counterpartyMultiSign(transaction);
   }
 
+  @Override
+  public <T extends Transaction> Signature sponsorSign(
+    final PrivateKeyReference privateKeyReference, final T transaction
+  ) {
+    Objects.requireNonNull(privateKeyReference);
+    Objects.requireNonNull(transaction);
+    return getTransactionSigner(privateKeyReference).sponsorSign(transaction);
+  }
+
+  @Override
+  public <T extends Transaction> Signature sponsorMultiSign(
+    final PrivateKeyReference privateKeyReference, final T transaction
+  ) {
+    Objects.requireNonNull(privateKeyReference);
+    Objects.requireNonNull(transaction);
+    return getTransactionSigner(privateKeyReference).sponsorMultiSign(transaction);
+  }
+
   @Override
   public <T extends Transaction> Signer multiSignToSigner(PrivateKeyReference privateKeyable, T transaction) {
     return getTransactionSigner(privateKeyable).multiSignToSigner(transaction);
@@ -372,6 +390,14 @@ public final Signature counterpartyMultiSign(final LoanSet transaction) {
       return bcSignatureService.counterpartyMultiSign(this.privateKey, transaction);
     }
 
+    public <T extends Transaction> Signature sponsorSign(final T transaction) {
+      return bcSignatureService.sponsorSign(this.privateKey, transaction);
+    }
+
+    public <T extends Transaction> Signature sponsorMultiSign(final T transaction) {
+      return bcSignatureService.sponsorMultiSign(this.privateKey, transaction);
+    }
+
     public PublicKey getPublicKey() {
       return BcKeyUtils.toPublicKey(this.privateKey);
     }