Fixes #474

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

@@ -9,9 +9,9 @@
  * 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.
@@ -41,7 +41,9 @@
 class AmountType extends SerializedType<AmountType> {
 
   public static final BigDecimal MAX_DROPS = new BigDecimal("1e17");
+  public static final BigDecimal MIN_DROPS = new BigDecimal("-1e17");
   public static final BigDecimal MIN_XRP = new BigDecimal("1e-6");
+  public static final BigDecimal MAX_NEGATIVE_XRP = new BigDecimal("-1e-6");
 
   public static final String DEFAULT_AMOUNT_HEX = "4000000000000000";
   public static final String ZERO_CURRENCY_AMOUNT_HEX = "8000000000000000";
@@ -50,18 +52,18 @@ class AmountType extends SerializedType<AmountType> {
   private static final int MAX_IOU_PRECISION = 16;
 
   /**
-   * According to <a href=https://xrpl.org/currency-formats.html#currency-formats>xrpl.org</a>,
-   * the minimum token value exponent is -96. However, because the value field is converted from a {@link String}
-   * to a {@link BigDecimal} when encoding/decoding, and because {@link BigDecimal} defaults to using single
-   * digit number, the minimum exponent in this context is -96 + 15, as XRPL amounts have a precision of 15 digits.
+   * According to <a href=https://xrpl.org/currency-formats.html#currency-formats>xrpl.org</a>, the minimum token value
+   * exponent is -96. However, because the value field is converted from a {@link String} to a {@link BigDecimal} when
+   * encoding/decoding, and because {@link BigDecimal} defaults to using single digit number, the minimum exponent in
+   * this context is -96 + 15, as XRPL amounts have a precision of 15 digits.
    */
   private static final int MIN_IOU_EXPONENT = -81;
 
   /**
-   * According to <a href=https://xrpl.org/currency-formats.html#currency-formats>xrpl.org</a>,
-   * the maximum token value exponent is 80. However, because the value field is converted from a {@link String}
-   * to a {@link BigDecimal} when encoding/decoding, and because {@link BigDecimal} defaults to using single
-   * digit number, the maximum exponent in this context is 80 + 15, as XRPL amounts have a precision of 15 digits.
+   * According to <a href=https://xrpl.org/currency-formats.html#currency-formats>xrpl.org</a>, the maximum token value
+   * exponent is 80. However, because the value field is converted from a {@link String} to a {@link BigDecimal} when
+   * encoding/decoding, and because {@link BigDecimal} defaults to using single digit number, the maximum exponent in
+   * this context is 80 + 15, as XRPL amounts have a precision of 15 digits.
    */
   private static final int MAX_IOU_EXPONENT = 95;
 
@@ -88,8 +90,14 @@ private static void assertXrpIsValid(String amount) {
     }
     BigDecimal value = new BigDecimal(amount);
     if (!value.equals(BigDecimal.ZERO)) {
-      if (value.compareTo(MIN_XRP) < 0 || value.compareTo(MAX_DROPS) > 0) {
-        throw new IllegalArgumentException(amount + " is an illegal amount");
+      if (value.signum() < 0) { // `value` is negative
+        if (value.compareTo(MAX_NEGATIVE_XRP) > 0 || value.compareTo(MIN_DROPS) < 0) {
+          throw new IllegalArgumentException(String.format("%s is an illegal amount", amount));
+        }
+      } else { // `value` is positive
+        if (value.compareTo(MIN_XRP) < 0 || value.compareTo(MAX_DROPS) > 0) {
+          throw new IllegalArgumentException(String.format("%s is an illegal amount", amount));
+        }
       }
     }
   }
@@ -142,14 +150,21 @@ public AmountType fromJson(JsonNode value) throws JsonProcessingException {
     if (value.isValueNode()) {
       assertXrpIsValid(value.asText());
 
-      UnsignedByteArray number = UnsignedByteArray.fromHex(
+      final boolean isValueNegative = value.asText().startsWith("-");
+      final UnsignedByteArray number = UnsignedByteArray.fromHex(
         ByteUtils.padded(
-          UnsignedLong.valueOf(value.asText()).toString(16),
-          64 / 4
+          UnsignedLong
+            .valueOf(isValueNegative ? value.asText().substring(1) : value.asText())
+            .toString(16),
+          16 // <-- 64 / 16
         )
       );
-      byte[] rawBytes = number.toByteArray();
-      rawBytes[0] |= 0x40;
+      final byte[] rawBytes = number.toByteArray();
+      if (isValueNegative) {
+        rawBytes[0] |= 0x00;
+      } else {
+        rawBytes[0] |= 0x40;
+      }
       return new AmountType(UnsignedByteArray.of(rawBytes));
     }
 

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/model/transactions/CurrencyAmount.java

@@ -20,6 +20,7 @@
  * =========================LICENSE_END==================================
  */
 
+import java.math.BigDecimal;
 import java.util.Objects;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -34,9 +35,17 @@ public interface CurrencyAmount {
   long ONE_XRP_IN_DROPS = 1_000_000L;
   long MAX_XRP = 100_000_000_000L; // <-- per https://xrpl.org/rippleapi-reference.html#value
   long MAX_XRP_IN_DROPS = MAX_XRP * ONE_XRP_IN_DROPS;
+  BigDecimal MAX_XRP_BD = BigDecimal.valueOf(MAX_XRP);
 
   /**
-   * Handle this {@link CurrencyAmount} depending on its actual polymorphic sub-type.
+   * Indicates whether this amount is positive or negative.
+   *
+   * @return {@code true} if this amount is negative; {@code false} otherwise (i.e., if the value is 0 or positive).
+   */
+  boolean isNegative();
+
+  /**
+   * Handle this {@link CurrencyAmount} depending on its actual polymorphic subtype.
    *
    * @param xrpCurrencyAmountHandler     A {@link Consumer} that is called if this instance is of type
    *                                     {@link XrpCurrencyAmount}.
@@ -60,7 +69,7 @@ default void handle(
   }
 
   /**
-   * Map this {@link CurrencyAmount} to an instance of {@link R}, depending on its actualy polymorphic sub-type.
+   * Map this {@link CurrencyAmount} to an instance of {@link R}, depending on its actual polymorphic subtype.
    *
    * @param xrpCurrencyAmountMapper    A {@link Function} that is called if this instance is of type
    *                                   {@link XrpCurrencyAmount}.

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/model/transactions/IssuedCurrencyAmount.java

@@ -9,9 +9,9 @@
  * 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.
@@ -20,9 +20,13 @@
  * =========================LICENSE_END==================================
  */
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import org.immutables.value.Value;
+import org.immutables.value.Value.Auxiliary;
+import org.immutables.value.Value.Default;
+import org.immutables.value.Value.Derived;
 
 /**
  * A {@link CurrencyAmount} for Issued Currencies on the XRP Ledger.
@@ -45,14 +49,14 @@ public interface IssuedCurrencyAmount extends CurrencyAmount {
   String MIN_VALUE = "-9999999999999999e80";
 
   /**
-   * The smallest possible positive value that an {@link IssuedCurrencyAmount} can have. Put another way,
-   * this value is the closest an {@link IssuedCurrencyAmount}'s {@link #value()} can be to zero if it is positive.
+   * The smallest possible positive value that an {@link IssuedCurrencyAmount} can have. Put another way, this value is
+   * the closest an {@link IssuedCurrencyAmount}'s {@link #value()} can be to zero if it is positive.
    */
   String MIN_POSITIVE_VALUE = "1000000000000000e-96";
 
   /**
-   * The largest possible negative value that an {@link IssuedCurrencyAmount} can have. Put another way,
-   * this value is the closest an {@link IssuedCurrencyAmount}'s {@link #value()} can be to zero if it is negative.
+   * The largest possible negative value that an {@link IssuedCurrencyAmount} can have. Put another way, this value is
+   * the closest an {@link IssuedCurrencyAmount}'s {@link #value()} can be to zero if it is negative.
    */
   String MAX_NEGATIVE_VALUE = "-1000000000000000e-96";
 
@@ -67,10 +71,10 @@ static ImmutableIssuedCurrencyAmount.Builder builder() {
 
   /**
    * Quoted decimal representation of the amount of currency. This can include scientific notation, such as 1.23e11
-   * meaning 123,000,000,000. Both e and E may be used. Note that while this implementation merely holds a {@link
-   * String} with no value restrictions, the XRP Ledger does not tolerate unlimited precision values. Instead, non-XRP
-   * values (i.e., values held in this object) can have up to 16 decimal digits of precision, with a maximum value of
-   * 9999999999999999e80. The smallest positive non-XRP value is 1e-81.
+   * meaning 123,000,000,000. Both e and E may be used. Note that while this implementation merely holds a
+   * {@link String} with no value restrictions, the XRP Ledger does not tolerate unlimited precision values. Instead,
+   * non-XRP values (i.e., values held in this object) can have up to 16 decimal digits of precision, with a maximum
+   * value of 9999999999999999e80. The smallest positive non-XRP value is 1e-81.
    *
    * @return A {@link String} containing the amount of this issued currency.
    */
@@ -91,4 +95,16 @@ static ImmutableIssuedCurrencyAmount.Builder builder() {
    */
   Address issuer();
 
+  /**
+   * Indicates whether this amount is positive or negative.
+   *
+   * @return {@code true} if this amount is negative; {@code false} otherwise (i.e., if the value is 0 or positive).
+   */
+  @Derived
+  @JsonIgnore // <-- This is not actually part of the binary serialization format, so exclude from JSON
+  @Auxiliary
+  default boolean isNegative() {
+    return value().startsWith("-");
+  }
+
 }