Batch PR2: Add initial Batch support

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

@@ -659,7 +659,7 @@ public <T extends XrplResult> T send(
         JsonRpcRequest request,
         JavaType resultType
       ) {
-        SubmitMultiSignedResult submitMultiSignedResult = SubmitMultiSignedResult.builder()
+        SubmitMultiSignedResult<?> submitMultiSignedResult = SubmitMultiSignedResult.builder()
           .engineResult("tesSUCCESS")
           .engineResultCode(200)
           .engineResultMessage("Submitted")

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/codec/binary/XrplBinaryCodec.java

@@ -34,6 +34,12 @@
 import org.xrpl.xrpl4j.codec.binary.types.AccountIdType;
 import org.xrpl.xrpl4j.codec.binary.types.STObjectType;
 import org.xrpl.xrpl4j.codec.binary.types.UInt64Type;
+import org.xrpl.xrpl4j.crypto.HashingUtils;
+import org.xrpl.xrpl4j.crypto.signing.SignedTransaction;
+import org.xrpl.xrpl4j.model.transactions.Address;
+import org.xrpl.xrpl4j.model.transactions.Batch;
+import org.xrpl.xrpl4j.model.transactions.Hash256;
+import org.xrpl.xrpl4j.model.transactions.RawTransactionWrapper;
 
 import java.util.Map;
 import java.util.Objects;
@@ -47,11 +53,13 @@ public class XrplBinaryCodec {
   public static final String TRX_MULTI_SIGNATURE_PREFIX = "534D5400";
 
   public static final String PAYMENT_CHANNEL_CLAIM_SIGNATURE_PREFIX = "434C4D00";
+  public static final String BATCH_SIGNATURE_PREFIX = "42434800"; // "BCH\0" per XLS-0056
+
   public static final String CHANNEL_FIELD_NAME = "Channel";
   public static final String AMOUNT_FIELD_NAME = "Amount";
 
-  private static final DefinitionsService definitionsService = DefinitionsService.getInstance();
-  private static final ObjectMapper objectMapper = BinaryCodecObjectMapperFactory.getObjectMapper();
+  private static final DefinitionsService DEFINITIONS_SERVICE = DefinitionsService.getInstance();
+  private static final ObjectMapper BINARY_CODEC_OBJECT_MAPPER = BinaryCodecObjectMapperFactory.getObjectMapper();
 
   private static final XrplBinaryCodec INSTANCE = new XrplBinaryCodec();
 
@@ -70,11 +78,12 @@ public static XrplBinaryCodec getInstance() {
    * @param json A {@link String} containing JSON to be encoded.
    *
    * @return A {@link String} containing the hex-encoded representation of {@code json}.
+   *
    * @throws JsonProcessingException if {@code json} is not valid JSON.
    */
   public String encode(String json) throws JsonProcessingException {
     Objects.requireNonNull(json);
-    JsonNode node = BinaryCodecObjectMapperFactory.getObjectMapper().readTree(json);
+    JsonNode node = BINARY_CODEC_OBJECT_MAPPER.readTree(json);
     return encode(node);
   }
 
@@ -84,7 +93,6 @@ public String encode(String json) throws JsonProcessingException {
    * @param jsonNode A {@link JsonNode} containing JSON to be encoded.
    *
    * @return A {@link String} containing the hex-encoded representation of {@code jsonNode}.
-   * @throws JsonProcessingException if {@code jsonNode} is not valid JSON.
    */
   private String encode(final JsonNode jsonNode) {
     Objects.requireNonNull(jsonNode);
@@ -99,10 +107,11 @@ private String encode(final JsonNode jsonNode) {
    * @param json String containing JSON to be encoded.
    *
    * @return hex encoded representations
+   *
    * @throws JsonProcessingException if JSON is not valid.
    */
   public String encodeForSigning(String json) throws JsonProcessingException {
-    JsonNode node = BinaryCodecObjectMapperFactory.getObjectMapper().readTree(json);
+    JsonNode node = BINARY_CODEC_OBJECT_MAPPER.readTree(json);
     return TRX_SIGNATURE_PREFIX + encode(removeNonSigningFields(node));
   }
 
@@ -113,10 +122,11 @@ public String encodeForSigning(String json) throws JsonProcessingException {
    * @param xrpAccountId A {@link String} containing the XRPL AccountId.
    *
    * @return hex encoded representations
+   *
    * @throws JsonProcessingException if JSON is not valid.
    */
   public String encodeForMultiSigning(String json, String xrpAccountId) throws JsonProcessingException {
-    JsonNode node = BinaryCodecObjectMapperFactory.getObjectMapper().readTree(json);
+    JsonNode node = BINARY_CODEC_OBJECT_MAPPER.readTree(json);
     if (!node.isObject()) {
       throw new IllegalArgumentException("JSON object required for signing");
     }
@@ -126,17 +136,86 @@ public String encodeForMultiSigning(String json, String xrpAccountId) throws Jso
     return TRX_MULTI_SIGNATURE_PREFIX + encode(removeNonSigningFields(node)) + suffix;
   }
 
+  /**
+   * Encodes a {@link Batch} transaction to canonical XRPL binary as a hex string for signing purposes. Note that this
+   * function slightly diverges from the pattern of the other encodeForSigning functions because the bytes to be signed
+   * for a Batch transaction are not simply the canonical binary representation of the JSON. Instead, we have distinct
+   * portions of the Batch transaction that are signed. Also, unlike {@link #encodeForSigning(String)}, which accepts
+   * JSON and then checks for JsonNode values, this implementation instead accepts a well-typed Java object and operates
+   * on that, for safety and correctness.
+   *
+   * @param batch A {@link Batch} containing JSON to be encoded.
+   *
+   * @return hex encoded representations
+   *
+   * @throws JsonProcessingException if JSON is not valid.
+   */
+  public UnsignedByteArray encodeForBatchInnerSigning(Batch batch) throws JsonProcessingException {
+    Objects.requireNonNull(batch);
+    try {
+      // Start with batch prefix (0x42434800 = "BCH\0")
+      UnsignedByteArray signableBytes = UnsignedByteArray.fromHex(XrplBinaryCodec.BATCH_SIGNATURE_PREFIX);
+
+      // Add flags (4 bytes, big-endian)
+      HashingUtils.addUInt32(signableBytes, (int) batch.flags().getValue());
+
+      // Add count of inner transactions (4 bytes, big-endian)
+      HashingUtils.addUInt32(signableBytes, batch.rawTransactions().size());
+
+      // Add each inner transaction ID (32 bytes each)
+      for (RawTransactionWrapper wrapper : batch.rawTransactions()) {
+        final UnsignedByteArray transactionId = computeInnerBatchTransactionId(wrapper);
+        signableBytes.append(transactionId);
+      }
+
+      return signableBytes;
+    } catch (JsonProcessingException e) {
+      throw new RuntimeException(e.getMessage(), e);
+    }
+  }
+
+  /**
+   * Encode a {@link Batch} for multi-signing by a specific signer. This is used when a multi-sig account acts as a
+   * BatchSigner with nested Signers. Per rippled's checkBatchMultiSign, this uses batch serialization (serializeBatch)
+   * followed by appending the signer's account ID (finishMultiSigningData).
+   *
+   * @param batch         The {@link Batch} to encode.
+   * @param signerAddress The address of the signer (will be appended as account ID suffix).
+   *
+   * @return An {@link UnsignedByteArray} containing the batch serialization with account ID suffix.
+   *
+   * @throws JsonProcessingException if there is an error processing the JSON.
+   */
+  public UnsignedByteArray encodeForBatchInnerMultiSigning(Batch batch, Address signerAddress)
+    throws JsonProcessingException {
+    Objects.requireNonNull(batch);
+    Objects.requireNonNull(signerAddress);
+
+    // Start with batch serialization (HashPrefix::batch + flags + count + tx IDs)
+    UnsignedByteArray batchBytes = encodeForBatchInnerSigning(batch);
+
+    // Create a copy to avoid mutating the original (since UnsignedByteArray.append() mutates)
+    UnsignedByteArray result = UnsignedByteArray.of(batchBytes.toByteArray());
+
+    // Append the signer's account ID (like finishMultiSigningData does in rippled)
+    String accountIdHex = new AccountIdType().fromJson(new TextNode(signerAddress.value())).toHex();
+    result.append(UnsignedByteArray.fromHex(accountIdHex));
+
+    return result;
+  }
+
   /**
    * Encodes JSON to canonical XRPL binary as a hex string for signing payment channel claims. The only JSON fields
    * which will be encoded are "Channel" and "Amount".
    *
    * @param json String containing JSON to be encoded.
    *
    * @return The binary encoded JSON in hexadecimal form.
+   *
    * @throws JsonProcessingException If the JSON is not valid.
    */
   public String encodeForSigningClaim(String json) throws JsonProcessingException {
-    JsonNode node = BinaryCodecObjectMapperFactory.getObjectMapper().readTree(json);
+    JsonNode node = BINARY_CODEC_OBJECT_MAPPER.readTree(json);
     if (!node.isObject()) {
       throw new IllegalArgumentException("JSON object required for signing");
     }
@@ -201,12 +280,40 @@ private JsonNode removeNonSigningFields(JsonNode node) {
       .filter(this::isSigningField)
       .collect(Collectors.toMap(Function.identity(), node::get));
 
-    return new ObjectNode(objectMapper.getNodeFactory(), signingFields);
+    return new ObjectNode(BINARY_CODEC_OBJECT_MAPPER.getNodeFactory(), signingFields);
   }
 
   private Boolean isSigningField(String fieldName) {
-    return definitionsService.getFieldInstance(fieldName).map(FieldInstance::isSigningField).orElse(false);
+    return DEFINITIONS_SERVICE.getFieldInstance(fieldName).map(FieldInstance::isSigningField).orElse(false);
   }
 
+  /**
+   * Computes the transaction ID for an unsigned inner transaction.
+   *
+   * @param rawTransactionWrapper A {@link RawTransactionWrapper} with an unsigned inner transaction, used for Batch.
+   *
+   * @return A {@link Hash256} containing the transaction's transaction ID.
+   */
+  private UnsignedByteArray computeInnerBatchTransactionId(final RawTransactionWrapper rawTransactionWrapper)
+    throws JsonProcessingException {
+    Objects.requireNonNull(rawTransactionWrapper);
 
+    String txJson = BINARY_CODEC_OBJECT_MAPPER.writeValueAsString(rawTransactionWrapper.rawTransaction());
+    // Parse the JSON and ensure SigningPubKey is set to empty string for inner transactions
+    JsonNode txNode = removeNonSigningFields(BINARY_CODEC_OBJECT_MAPPER.readTree(txJson));
+    if (txNode.isObject()) {
+      final ObjectNode objNode = (ObjectNode) txNode;
+      // Fix Flags field if it's serialized as an object instead of a number
+      // NOTE: Once https://github.com/XRPLF/xrpl4j/issues/649 is implemented, this line can be removed.
+      final JsonNode flagsNode = objNode.get("Flags");
+      if (flagsNode != null && flagsNode.isObject() && flagsNode.has("value")) {
+        objNode.put("Flags", flagsNode.get("value").asLong());
+      }
+    }
+    final String txHex = this.encode(txNode);
+    final UnsignedByteArray txBytes = UnsignedByteArray.fromHex(
+      SignedTransaction.SIGNED_TRANSACTION_HASH_PREFIX + txHex
+    );
+    return HashingUtils.sha512Half(txBytes);
+  }
 }

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/HashingUtils.java

@@ -29,7 +29,7 @@
 import java.util.Objects;
 
 /**
- * Hashing utilities for XRPL related hashing algorithms.
+ * Hashing utilities for XRPL-related hashing algorithms.
  */
 public class HashingUtils {
 

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/AbstractSignatureService.java

@@ -27,6 +27,7 @@
 import org.xrpl.xrpl4j.crypto.keys.PublicKey;
 import org.xrpl.xrpl4j.model.client.channels.UnsignedClaim;
 import org.xrpl.xrpl4j.model.ledger.Attestation;
+import org.xrpl.xrpl4j.model.transactions.Batch;
 import org.xrpl.xrpl4j.model.transactions.Signer;
 import org.xrpl.xrpl4j.model.transactions.Transaction;
 
@@ -97,21 +98,31 @@ public <T extends Transaction> SingleSignedTransaction<T> sign(final P privateKe
     return this.abstractTransactionSigner.sign(privateKeyable, transaction);
   }
 
+  @Override
+  public Signature sign(final P privateKeyable, final Attestation attestation) {
+    return this.abstractTransactionSigner.sign(privateKeyable, attestation);
+  }
+
   @Override
   public Signature sign(final P privateKeyable, final UnsignedClaim unsignedClaim) {
     return this.abstractTransactionSigner.sign(privateKeyable, unsignedClaim);
   }
 
   @Override
-  public Signature sign(P privateKeyable, Attestation attestation) {
-    return this.abstractTransactionSigner.sign(privateKeyable, attestation);
+  public Signature signInner(final P privateKeyable, final Batch batchTransaction) {
+    return this.abstractTransactionSigner.signInner(privateKeyable, batchTransaction);
   }
 
   @Override
   public <T extends Transaction> Signature multiSign(final P privateKeyable, final T transaction) {
     return abstractTransactionSigner.multiSign(privateKeyable, transaction);
   }
 
+  @Override
+  public Signature multiSignInner(final P privateKeyable, final Batch batchTransaction) {
+    return abstractTransactionSigner.multiSignInner(privateKeyable, batchTransaction);
+  }
+
   @Override
   public <T extends Transaction> boolean verify(final Signer signer, final T unsignedTransaction) {
     return abstractTransactionVerifier.verify(signer, unsignedTransaction);

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/AbstractTransactionSigner.java

@@ -27,6 +27,7 @@
 import org.xrpl.xrpl4j.model.client.channels.UnsignedClaim;
 import org.xrpl.xrpl4j.model.ledger.Attestation;
 import org.xrpl.xrpl4j.model.transactions.Address;
+import org.xrpl.xrpl4j.model.transactions.Batch;
 import org.xrpl.xrpl4j.model.transactions.Transaction;
 
 import java.util.Objects;
@@ -77,17 +78,35 @@ public Signature sign(P privateKeyable, Attestation attestation) {
     return this.signingHelper(privateKeyable, signableBytes);
   }
 
+  @Override
+  public Signature signInner(final P privateKeyable, final Batch batchTransaction) {
+    Objects.requireNonNull(privateKeyable);
+    Objects.requireNonNull(batchTransaction);
+    final UnsignedByteArray signableBytes = this.signatureUtils.toSignableInnerBytes(batchTransaction);
+    return this.signingHelper(privateKeyable, signableBytes);
+  }
+
   @Override
   public <T extends Transaction> Signature multiSign(final P privateKeyable, final T transaction) {
     Objects.requireNonNull(privateKeyable);
     Objects.requireNonNull(transaction);
 
     final Address address = derivePublicKey(privateKeyable).deriveAddress();
     final UnsignedByteArray signableTransactionBytes = this.signatureUtils.toMultiSignableBytes(transaction, address);
-
     return this.signingHelper(privateKeyable, signableTransactionBytes);
   }
 
+  @Override
+  public Signature multiSignInner(final P privateKeyable, final Batch batchTransaction) {
+    Objects.requireNonNull(privateKeyable);
+    Objects.requireNonNull(batchTransaction);
+
+    final Address address = derivePublicKey(privateKeyable).deriveAddress();
+    final UnsignedByteArray signableBytes = this.signatureUtils.toMultiSignableInnerBytes(batchTransaction, address);
+
+    return this.signingHelper(privateKeyable, signableBytes);
+  }
+
   /**
    * Helper to generate a signature based upon an {@link UnsignedByteArray} of transaction bytes.
    *