Merge pull request #250 from atoulme/uint_fixes

UInt compat fixes

Author: atoulme

evm/src/main/kotlin/org/apache/tuweni/evm/impl/berlin/OpCodes.kt

@@ -102,7 +102,7 @@ val slt = Opcode { gasManager, _, stack, _, _, _, _ ->
   if (null == item || null == item2) {
     Result(EVMExecutionStatusCode.STACK_UNDERFLOW)
   } else {
-    if (item.toBigInteger() < item2.toBigInteger()) {
+    if (item.toSignedBigInteger() < item2.toSignedBigInteger()) {
       stack.push(UInt256.ONE)
     } else {
       stack.push(UInt256.ZERO)
@@ -134,7 +134,7 @@ val sgt = Opcode { gasManager, _, stack, _, _, _, _ ->
   if (null == item || null == item2) {
     Result(EVMExecutionStatusCode.STACK_UNDERFLOW)
   } else {
-    if (item.toBigInteger() > item2.toBigInteger()) {
+    if (item.toSignedBigInteger() > item2.toSignedBigInteger()) {
       stack.push(UInt256.ONE)
     } else {
       stack.push(UInt256.ZERO)

units/src/main/java/org/apache/tuweni/units/bigints/BaseUInt256Value.java

@@ -19,6 +19,7 @@
 import org.apache.tuweni.bytes.MutableBytes32;
 
 import java.math.BigInteger;
+import java.nio.ByteOrder;
 import java.util.function.Function;
 
 /**
@@ -381,4 +382,9 @@ public Bytes slice(int i, int length) {
   public MutableBytes32 mutableCopy() {
     return MutableBytes32.wrap(value.toArrayUnsafe());
   }
+
+  @Override
+  public long toLong(ByteOrder order) {
+    return value.toLong(order);
+  }
 }

units/src/main/java/org/apache/tuweni/units/bigints/UInt256.java

@@ -451,7 +451,7 @@ public UInt256 sdiv0(UInt256 divisor) {
     if (divisor.isZero()) {
       return UInt256.ZERO;
     } else {
-      BigInteger result = this.toBigInteger().divide(divisor.toBigInteger());
+      BigInteger result = this.toSignedBigInteger().divide(divisor.toSignedBigInteger());
       Bytes resultBytes = Bytes.wrap(result.toByteArray());
       if (resultBytes.size() > 32) {
         resultBytes = resultBytes.slice(resultBytes.size() - 32, 32);
@@ -532,8 +532,8 @@ public UInt256 smod0(UInt256 modulus) {
       return UInt256.ZERO;
     }
 
-    BigInteger bi = this.toBigInteger();
-    BigInteger result = bi.abs().mod(modulus.toBigInteger().abs());
+    BigInteger bi = this.toSignedBigInteger();
+    BigInteger result = bi.abs().mod(modulus.toSignedBigInteger().abs());
 
     if (bi.signum() < 0) {
       result = result.negate();

units/src/main/java/org/apache/tuweni/units/bigints/UInt256Value.java

@@ -13,9 +13,14 @@
 package org.apache.tuweni.units.bigints;
 
 
+import static java.nio.ByteOrder.BIG_ENDIAN;
+
 import org.apache.tuweni.bytes.Bytes;
 import org.apache.tuweni.bytes.Bytes32;
 
+import java.math.BigInteger;
+import java.nio.ByteOrder;
+
 
 /**
  * Represents a 256-bit (32 bytes) unsigned integer value.
@@ -336,13 +341,33 @@ default T subtractExact(long value) {
    * @return True if this value fits a java {@code int} (i.e. is less or equal to {@code Integer.MAX_VALUE}).
    */
   default boolean fitsInt() {
-    // Ints are 4 bytes, so anything but the 4 last bytes must be zeroes
-    for (int i = 0; i < Bytes32.SIZE - 4; i++) {
-      if (get(i) != 0)
-        return false;
+    return fitsInt(ByteOrder.BIG_ENDIAN);
+  }
+
+  /**
+   * Returns true if the value can fit in an int according to the byte order.
+   *
+   * @param order the byte order, little or big endian
+   * @return True if this value fits a java {@code int} (i.e. is less or equal to {@code Integer.MAX_VALUE}).
+   */
+  default boolean fitsInt(ByteOrder order) {
+    if (order == ByteOrder.BIG_ENDIAN) {
+      // Ints are 4 bytes, so anything but the 4 last bytes must be zeroes
+      for (int i = 0; i < Bytes32.SIZE - 4; i++) {
+        if (get(i) != 0)
+          return false;
+      }
+      // Lastly, the left-most byte of the int must not start with a 1.
+      return get(Bytes32.SIZE - 4) >= 0;
+    } else {
+      // Ints are 4 bytes, so only the 4 first bytes must not be zeroes
+      for (int i = 4; i < Bytes32.SIZE - 4; i++) {
+        if (get(i) != 0)
+          return false;
+      }
+      // Lastly, the right-most byte of the int must not start with a 1.
+      return get(3) >= 0;
     }
-    // Lastly, the left-most byte of the int must not start with a 1.
-    return get(Bytes32.SIZE - 4) >= 0;
   }
 
   /**
@@ -358,19 +383,63 @@ default int intValue() {
     return getInt(Bytes32.SIZE - 4);
   }
 
+  @Override
+  default int toInt(ByteOrder order) {
+    if (!fitsInt(order)) {
+      throw new ArithmeticException("Value does not fit a 4 byte int");
+    }
+    if (order == ByteOrder.BIG_ENDIAN) {
+      return getInt(Bytes32.SIZE - 4, order);
+    } else {
+      return getInt(0, order);
+    }
+  }
+
+  @Override
+  default long toLong(ByteOrder order) {
+    if (!fitsLong(order)) {
+      throw new ArithmeticException("Value does not fit a 8 byte long");
+    }
+    if (order == ByteOrder.BIG_ENDIAN) {
+      return getLong(Bytes32.SIZE - 8, order);
+    } else {
+      return getLong(0, order);
+    }
+  }
+
   /**
    * Returns true if the value can fit in a long.
    *
    * @return True if this value fits a java {@code long} (i.e. is less or equal to {@code Long.MAX_VALUE}).
    */
   default boolean fitsLong() {
-    // Longs are 8 bytes, so anything but the 8 last bytes must be zeroes
-    for (int i = 0; i < Bytes32.SIZE - 8; i++) {
-      if (get(i) != 0)
-        return false;
+    return fitsLong(ByteOrder.BIG_ENDIAN);
+  }
+
+  /**
+   * Returns true if the value can fit in a long.
+   *
+   * @param order byte order, little or big endian
+   * @return True if this value fits a java {@code long} (i.e. is less or equal to {@code Long.MAX_VALUE}).
+   */
+  default boolean fitsLong(ByteOrder order) {
+    if (order == ByteOrder.BIG_ENDIAN) {
+      // Longs are 8 bytes, so anything but the 8 last bytes must be zeroes
+      for (int i = 0; i < Bytes32.SIZE - 8; i++) {
+        if (get(i) != 0)
+          return false;
+      }
+      // Lastly, the left-most byte of the long must not start with a 1.
+      return get(Bytes32.SIZE - 8) >= 0;
+    } else {
+      // Longs are 8 bytes, so only the 8 first bytes may not be zeroes
+      for (int i = 8; i < Bytes32.SIZE; i++) {
+        if (get(i) != 0)
+          return false;
+      }
+      // Lastly, the left-most byte of the long must not start with a 1.
+      return get(7) >= 0;
     }
-    // Lastly, the left-most byte of the long must not start with a 1.
-    return get(Bytes32.SIZE - 8) >= 0;
   }
 
   /**
@@ -433,4 +502,56 @@ default boolean lessThan(UInt256Value<T> other) {
   default boolean lessOrEqualThan(UInt256Value<T> other) {
     return compareTo(other) <= 0;
   }
+
+  /**
+   * Returns the decimal representation of this value as a String.
+   *
+   * @return the decimal representation of this value as a String.
+   */
+  default String toDecimalString() {
+    return toBigInteger().toString(10);
+  }
+
+  /**
+   * The BigInteger corresponding to interpreting these bytes as a two's-complement signed integer.
+   *
+   * @return A {@link BigInteger} corresponding to interpreting these bytes as a two's-complement signed integer.
+   */
+  default BigInteger toSignedBigInteger() {
+    return toSignedBigInteger(BIG_ENDIAN);
+  }
+
+  /**
+   * The BigInteger corresponding to interpreting these bytes as a two's-complement signed integer.
+   *
+   * @param order The byte-order for decoding the integer.
+   * @return A {@link BigInteger} corresponding to interpreting these bytes as a two's-complement signed integer.
+   */
+  default BigInteger toSignedBigInteger(ByteOrder order) {
+    if (size() == 0) {
+      return BigInteger.ZERO;
+    }
+    return new BigInteger((order == BIG_ENDIAN) ? toArrayUnsafe() : reverse().toArrayUnsafe());
+  }
+
+  /**
+   * The BigInteger corresponding to interpreting these bytes as an unsigned integer.
+   *
+   * @return A positive (or zero) {@link BigInteger} corresponding to interpreting these bytes as an unsigned integer.
+   */
+  @Override
+  default BigInteger toBigInteger() {
+    return toUnsignedBigInteger();
+  }
+
+  /**
+   * The BigInteger corresponding to interpreting these bytes as an unsigned integer.
+   *
+   * @param order The byte-order for decoding the integer.
+   * @return A positive (or zero) {@link BigInteger} corresponding to interpreting these bytes as an unsigned integer.
+   */
+  @Override
+  default BigInteger toBigInteger(ByteOrder order) {
+    return toUnsignedBigInteger(order);
+  }
 }

units/src/main/java/org/apache/tuweni/units/bigints/UInt32Value.java

@@ -390,4 +390,13 @@ default int numberOfLeadingZeros() {
   default int bitLength() {
     return toBytes().bitLength();
   }
+
+  /**
+   * Returns the decimal representation of this value as a String.
+   *
+   * @return the decimal representation of this value as a String.
+   */
+  default String toDecimalString() {
+    return toBigInteger().toString(10);
+  }
 }

units/src/main/java/org/apache/tuweni/units/bigints/UInt384Value.java

@@ -409,4 +409,13 @@ default int numberOfLeadingZeros() {
   default int bitLength() {
     return toBytes().bitLength();
   }
+
+  /**
+   * Returns the decimal representation of this value as a String.
+   *
+   * @return the decimal representation of this value as a String.
+   */
+  default String toDecimalString() {
+    return toBigInteger().toString(10);
+  }
 }

units/src/main/java/org/apache/tuweni/units/bigints/UInt64Value.java

@@ -403,4 +403,13 @@ default int numberOfLeadingZeros() {
   default int bitLength() {
     return toBytes().bitLength();
   }
+
+  /**
+   * Returns the decimal representation of this value as a String.
+   *
+   * @return the decimal representation of this value as a String.
+   */
+  default String toDecimalString() {
+    return toBigInteger().toString(10);
+  }
 }

units/src/test/java/org/apache/tuweni/units/bigints/UInt256Test.java

@@ -1168,4 +1168,9 @@ private void assertValueEquals(UInt256 expected, UInt256 actual) {
     String msg = String.format("Expected %s but got %s", expected.toHexString(), actual.toHexString());
     assertEquals(expected, actual, msg);
   }
+
+  @Test
+  void testToDecimalString() {
+    assertEquals("3456", UInt256.valueOf(3456).toDecimalString());
+  }
 }

units/src/test/java/org/apache/tuweni/units/bigints/UInt32Test.java

@@ -863,4 +863,8 @@ void toLongTooLarge() {
     assertEquals(4294967295L, UInt32.MAX_VALUE.toLong());
   }
 
+  @Test
+  void testToDecimalString() {
+    assertEquals("3456", UInt32.valueOf(3456).toDecimalString());
+  }
 }

units/src/test/java/org/apache/tuweni/units/bigints/UInt384Test.java

@@ -1096,4 +1096,9 @@ private void assertValueEquals(UInt384 expected, UInt384 actual) {
     String msg = String.format("Expected %s but got %s", expected.toHexString(), actual.toHexString());
     assertEquals(expected, actual, msg);
   }
+
+  @Test
+  void testToDecimalString() {
+    assertEquals("3456", UInt384.valueOf(3456).toDecimalString());
+  }
 }