Proxy test implemented

Basic utils fixes
Proxy provider fixes

Author: GoodforGod

src/main/java/io/api/etherscan/core/impl/ProxyApiProvider.java

@@ -45,7 +45,7 @@ public class ProxyApiProvider extends BasicProvider implements IProxyApi {
     private static final String ACT_ESTIMATEGAS_PARAM = ACT_PREFIX + "eth_estimateGas";
 
     private static final String BOOLEAN_PARAM = "&boolean=true";
-    private static final String TAG_LAST_PARAM = "&tag=lastest";
+    private static final String TAG_LAST_PARAM = "&tag=latest";
     private static final String POSITION_PARAM = "&position=";
     private static final String ADDRESS_PARAM = "&address=";
     private static final String TXHASH_PARAM = "&txhash=";
@@ -67,7 +67,7 @@ public long blockNoLast() throws ApiException {
         final StringProxyTO response = getRequest(ACT_BLOCKNO_PARAM, StringProxyTO.class);
         return (BasicUtils.isEmpty(response.getResult()))
                 ? -1
-                : BasicUtils.parseHex(response.getResult());
+                : BasicUtils.parseHex(response.getResult()).longValue();
     }
 
     @NotNull
@@ -105,19 +105,19 @@ public Optional<TxProxy> tx(final String txhash) throws ApiException {
     @Override
     public Optional<TxProxy> tx(final long blockNo, final long index) throws ApiException {
         final long compBlockNo = BasicUtils.compensateMinBlock(blockNo);
-        final long compIndex = BasicUtils.compensateMinBlock(index);
+        final long compIndex = (index < 1) ? 1 : index;
 
-        final String urlParams = ACT_TX_BY_BLOCKNOINDEX_PARAM + TAG_PARAM + compBlockNo + INDEX_PARAM + compIndex;
+        final String urlParams = ACT_TX_BY_BLOCKNOINDEX_PARAM + TAG_PARAM + compBlockNo + INDEX_PARAM + "0x" + Long.toHexString(compIndex);
         final TxProxyTO response = getRequest(urlParams, TxProxyTO.class);
         return Optional.ofNullable(response.getResult());
     }
 
     @Override
     public int txCount(final long blockNo) throws ApiException {
         final long compensatedBlockNo = BasicUtils.compensateMinBlock(blockNo);
-        final String urlParams = ACT_BLOCKTX_COUNT_PARAM + TAG_PARAM + compensatedBlockNo;
+        final String urlParams = ACT_BLOCKTX_COUNT_PARAM + TAG_PARAM + "0x" + Long.toHexString(compensatedBlockNo);
         final StringProxyTO response = getRequest(urlParams, StringProxyTO.class);
-        return Integer.valueOf(response.getResult());
+        return BasicUtils.parseHex(response.getResult()).intValue();
     }
 
     @Override
@@ -126,7 +126,7 @@ public int txSendCount(final String address) throws ApiException {
 
         final String urlParams = ACT_TX_COUNT_PARAM + ADDRESS_PARAM + address + TAG_LAST_PARAM;
         final StringProxyTO response = getRequest(urlParams, StringProxyTO.class);
-        return (int) BasicUtils.parseHex(response.getResult());
+        return BasicUtils.parseHex(response.getResult()).intValue();
     }
 
     @Override
@@ -160,6 +160,8 @@ public Optional<TxInfoProxy> txReceipt(final String txhash) throws ApiException
     @Override
     public Optional<String> call(final String address, final String data) throws ApiException {
         BasicUtils.validateAddress(address);
+        if(BasicUtils.isNotHex(data))
+            throw new InvalidDataHexException("Data is not hex encoded.");
 
         final String urlParams = ACT_CALL_PARAM + TO_PARAM + address + DATA_PARAM + data + TAG_LAST_PARAM;
         final StringProxyTO response = getRequest(urlParams, StringProxyTO.class);
@@ -199,7 +201,7 @@ public BigInteger gasPrice() throws ApiException {
         final StringProxyTO response = getRequest(ACT_GASPRICE_PARAM, StringProxyTO.class);
         return (BasicUtils.isEmpty(response.getResult()))
                 ? BigInteger.valueOf(-1)
-                : BigInteger.valueOf(BasicUtils.parseHex(response.getResult()));
+                : BasicUtils.parseHex(response.getResult());
     }
 
     @NotNull
@@ -211,13 +213,13 @@ public BigInteger gasEstimated() throws ApiException {
     @NotNull
     @Override
     public BigInteger gasEstimated(final String hexData) throws ApiException {
-        if(BasicUtils.isNotHex(hexData))
+        if(!BasicUtils.isEmpty(hexData) && BasicUtils.isNotHex(hexData))
             throw new InvalidDataHexException("Data is not in hex format.");
 
         final String urlParams = ACT_ESTIMATEGAS_PARAM + DATA_PARAM + hexData + GAS_PARAM + "2000000000000000";
         final StringProxyTO response = getRequest(urlParams, StringProxyTO.class);
         return (BasicUtils.isEmpty(response.getResult()))
                 ? BigInteger.valueOf(-1)
-                : BigInteger.valueOf(BasicUtils.parseHex(response.getResult()));
+                : BasicUtils.parseHex(response.getResult());
     }
 }

src/main/java/io/api/etherscan/util/BasicUtils.java

@@ -7,6 +7,7 @@
 import io.api.etherscan.model.utility.BlockParam;
 import org.jetbrains.annotations.NotNull;
 
+import java.math.BigInteger;
 import java.util.*;
 import java.util.regex.Pattern;
 
@@ -69,18 +70,25 @@ public static boolean isNotAddress(String value) {
     }
 
     public static boolean isNotTxHash(String value) {
-        return isEmpty(value) || !TXHASH_PATTERN.matcher(value).matches();
+        return isEmpty(value) || !TXHASH_PATTERN.matcher(value).find();
     }
 
     public static boolean isNotHex(String value) {
         return isEmpty(value) || !HEX_PATTERN.matcher(value).matches();
     }
 
-    public static long parseHex(String hex) {
+    public static BigInteger parseHex(String hex) {
         try {
-            return Long.valueOf(hex, 16);
+            if(BasicUtils.isEmpty(hex))
+                return BigInteger.valueOf(0);
+
+            final String formatted = (hex.length() > 2 && hex.charAt(0) == '0' && hex.charAt(1) == 'x')
+                    ? hex.substring(2, hex.length())
+                    : hex;
+
+            return new BigInteger(formatted, 16);
         } catch (NumberFormatException e) {
-            return -1;
+            return BigInteger.valueOf(-1L);
         }
     }
 

src/test/java/io/api/etherscan/proxy/ProxyBlockApiTest.java

@@ -0,0 +1,39 @@
+package io.api.etherscan.proxy;
+
+import io.api.etherscan.core.impl.EtherScanApi;
+import io.api.etherscan.model.proxy.BlockProxy;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Optional;
+
+/**
+ * ! NO DESCRIPTION !
+ *
+ * @author GoodforGod
+ * @since 03.11.2018
+ */
+public class ProxyBlockApiTest extends Assert {
+
+    private final EtherScanApi api = new EtherScanApi();
+
+    @Test
+    public void correct() {
+        Optional<BlockProxy> block = api.proxy().block(5120);
+        assertTrue(block.isPresent());
+        assertNotNull(block.get().getHash());
+    }
+
+    @Test
+    public void correctParamWithEmptyExpectedResult() {
+        Optional<BlockProxy> block = api.proxy().block(99999999999L);
+        assertFalse(block.isPresent());
+    }
+
+    @Test
+    public void correctParamNegativeNo() {
+        Optional<BlockProxy> block = api.proxy().block(-1);
+        assertTrue(block.isPresent());
+        assertNotNull(block.get().getHash());
+    }
+}

src/test/java/io/api/etherscan/proxy/ProxyCallApiTest.java

@@ -0,0 +1,49 @@
+package io.api.etherscan.proxy;
+
+import io.api.etherscan.core.impl.EtherScanApi;
+import io.api.etherscan.error.InvalidAddressException;
+import io.api.etherscan.error.InvalidDataHexException;
+import io.api.etherscan.util.BasicUtils;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Optional;
+
+/**
+ * ! NO DESCRIPTION !
+ *
+ * @author GoodforGod
+ * @since 03.11.2018
+ */
+public class ProxyCallApiTest extends Assert {
+
+    private final EtherScanApi api = new EtherScanApi();
+
+    @Test
+    public void correct() {
+        Optional<String> call = api.proxy().call("0xAEEF46DB4855E25702F8237E8f403FddcaF931C0",
+                "0x70a08231000000000000000000000000e16359506c028e51f16be38986ec5746251e9724");
+        assertTrue(call.isPresent());
+        assertFalse(BasicUtils.isNotHex(call.get()));
+    }
+
+    @Test(expected = InvalidAddressException.class)
+    public void invalidParamWithError() {
+        Optional<String> call = api.proxy().call("0xEEF46DB4855E25702F8237E8f403FddcaF931C0",
+                "0x70a08231000000000000000000000000e16359506c028e51f16be38986ec5746251e9724");
+    }
+
+    @Test(expected = InvalidDataHexException.class)
+    public void invalidParamNotHex() {
+        Optional<String> call = api.proxy().call("0xAEEF46DB4855E25702F8237E8f403FddcaF931C0",
+                "7-0a08231000000000000000000000000e16359506c028e51f16be38986ec5746251e9724");
+    }
+
+    @Test
+    public void correctParamWithEmptyExpectedResult() {
+        Optional<String> call = api.proxy().call("0xAEEF16DB4855E25702F8237E8f403FddcaF931C0",
+                "0x70a08231000000000000000000000000e16359506c028e51f16be38986ec5746251e9724");
+        assertTrue(call.isPresent());
+        assertFalse(BasicUtils.isNotHex(call.get()));
+    }
+}

src/test/java/io/api/etherscan/proxy/ProxyCodeApiTest.java

@@ -0,0 +1,39 @@
+package io.api.etherscan.proxy;
+
+import io.api.etherscan.core.impl.EtherScanApi;
+import io.api.etherscan.error.InvalidAddressException;
+import io.api.etherscan.util.BasicUtils;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Optional;
+
+/**
+ * ! NO DESCRIPTION !
+ *
+ * @author GoodforGod
+ * @since 03.11.2018
+ */
+public class ProxyCodeApiTest extends Assert{
+
+    private final EtherScanApi api = new EtherScanApi();
+
+    @Test
+    public void correct() {
+        Optional<String> call = api.proxy().code("0xf75e354c5edc8efed9b59ee9f67a80845ade7d0c");
+        assertTrue(call.isPresent());
+        assertFalse(BasicUtils.isNotHex(call.get()));
+    }
+
+    @Test(expected = InvalidAddressException.class)
+    public void invalidParamWithError() {
+        Optional<String> call = api.proxy().code("0f75e354c5edc8efed9b59ee9f67a80845ade7d0c");
+    }
+
+    @Test
+    public void correctParamWithEmptyExpectedResult() {
+        Optional<String> call = api.proxy().code("0xf15e354c5edc8efed9b59ee9f67a80845ade7d0c");
+        assertTrue(call.isPresent());
+        assertFalse(BasicUtils.isNotHex(call.get()));
+    }
+}

src/test/java/io/api/etherscan/proxy/ProxyGasApiTest.java

@@ -0,0 +1,49 @@
+package io.api.etherscan.proxy;
+
+import io.api.etherscan.core.impl.EtherScanApi;
+import io.api.etherscan.error.InvalidDataHexException;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.math.BigInteger;
+
+/**
+ * ! NO DESCRIPTION !
+ *
+ * @author GoodforGod
+ * @since 03.11.2018
+ */
+public class ProxyGasApiTest extends Assert{
+
+    private final EtherScanApi api = new EtherScanApi();
+
+    @Test
+    public void correctPrice() {
+        BigInteger price = api.proxy().gasPrice();
+        assertNotNull(price);
+        assertNotEquals(0, price.intValue());
+    }
+
+    @Test
+    public void correctEstimated() {
+        BigInteger price = api.proxy().gasEstimated();
+        assertNotNull(price);
+        assertNotEquals(0, price.intValue());
+    }
+
+    @Test
+    public void correctEstimatedWithData() {
+        String dataCustom = "606060405260728060106000396000f360606040526000606060405260728060106000396000f360606040526000";
+        BigInteger price = api.proxy().gasEstimated();
+        BigInteger priceCustom = api.proxy().gasEstimated(dataCustom);
+        assertNotNull(price);
+        assertNotNull(priceCustom);
+        assertNotEquals(price, priceCustom);
+    }
+
+    @Test(expected = InvalidDataHexException.class)
+    public void invalidParamWithError() {
+        String dataCustom = "280&60106000396000f360606040526000";
+        BigInteger priceCustom = api.proxy().gasEstimated(dataCustom);
+    }
+}

src/test/java/io/api/etherscan/proxy/ProxyStorageApiTest.java

@@ -0,0 +1,39 @@
+package io.api.etherscan.proxy;
+
+import io.api.etherscan.core.impl.EtherScanApi;
+import io.api.etherscan.error.InvalidAddressException;
+import io.api.etherscan.util.BasicUtils;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Optional;
+
+/**
+ * ! NO DESCRIPTION !
+ *
+ * @author GoodforGod
+ * @since 03.11.2018
+ */
+public class ProxyStorageApiTest extends Assert{
+
+    private final EtherScanApi api = new EtherScanApi();
+
+    @Test
+    public void correct() {
+        Optional<String> call = api.proxy().storageAt("0x6e03d9cce9d60f3e9f2597e13cd4c54c55330cfd", 0);
+        assertTrue(call.isPresent());
+        assertFalse(BasicUtils.isNotHex(call.get()));
+    }
+
+    @Test(expected = InvalidAddressException.class)
+    public void invalidParamWithError() {
+        Optional<String> call = api.proxy().storageAt("0xe03d9cce9d60f3e9f2597e13cd4c54c55330cfd", 0);
+    }
+
+    @Test
+    public void correctParamWithEmptyExpectedResult() {
+        Optional<String> call = api.proxy().storageAt("0x6e03d9cce9d60f3e9f2597e13cd4c54c55330cfd", 100);
+        assertTrue(call.isPresent());
+        assertFalse(BasicUtils.isNotHex(call.get()));
+    }
+}