USE_FINGERPRINT & bump version

* FOREGROUND_SERVICE for Android 9

* USE_BIOMETRIC for Android 9

.gitignore

@@ -6,4 +6,11 @@
 /captures
 .externalNativeBuild
 .DS_Store
+/app/build
 /app/release
+/app/alpha
+/app/prod
+/app/alphaMainnet
+/app/prodMainnet
+/app/alphaStagenet
+/app/prodStagenet

.idea/gradle.xml

@@ -3,6 +3,7 @@
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
+        <option name="disableWrapperSourceDistributionNotification" value="true" />
         <option name="distributionType" value="DEFAULT_WRAPPED" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
         <option name="modules">

README.md

@@ -22,12 +22,8 @@ Help us translate Monerujo! You can find instructions [On Taiga](https://taiga.g
 You may lose all your Moneroj if you use this App. Be cautious when spending on the mainnet.
 
 ### Random Notes
-- Based off monero v0.11.1.0
-- currently only android32 (runs on 64-bit as well)
-- works on the testnet & mainnet
-- sync is slow due to 32-bit architecture
+- works on the mainnet & stagenet
 - use your own daemon - it's easy
-- screen stays on until first sync is complete
 - Monerujo means "Monero Wallet" according to https://www.reddit.com/r/Monero/comments/3exy7t/esperanto_corner/
 
 ### TODO
@@ -43,13 +39,8 @@ of the "real" testnet.  After creating a new wallet, make a **new** one by recov
 The official monero client shows the same behaviour.
 
 ### HOW TO BUILD
-No need to build. Binaries are included:
 
-- openssl-1.0.2l
-- monero-v0.12
-- boost_1_58_0
-
-If you want to build them yourself (recommended) check out [the instructions](doc/BUILDING-external-libs.md)
+See [the instructions](doc/BUILDING-external-libs.md)
 
 Then, fire up Android Studio and build the APK.
 

app/.gitignore

@@ -1,3 +0,0 @@
-.externalNativeBuild
-build
-app.iml

app/CMakeLists.txt

@@ -7,13 +7,21 @@ add_library( monerujo
 
 set(EXTERNAL_LIBS_DIR ${CMAKE_SOURCE_DIR}/../external-libs)
 
+############
+# libsodium
+############
+
+add_library(sodium STATIC IMPORTED)
+set_target_properties(sodium PROPERTIES IMPORTED_LOCATION
+        ${EXTERNAL_LIBS_DIR}/libsodium/lib/${ANDROID_ABI}/libsodium.a)
+
 ############
 # OpenSSL
 ############
 
 add_library(crypto STATIC IMPORTED)
 set_target_properties(crypto PROPERTIES IMPORTED_LOCATION
-    ${EXTERNAL_LIBS_DIR}/openssl/lib/${ANDROID_ABI}/libcrypto.a)
+        ${EXTERNAL_LIBS_DIR}/openssl/lib/${ANDROID_ABI}/libcrypto.a)
 
 add_library(ssl STATIC IMPORTED)
 set_target_properties(ssl PROPERTIES IMPORTED_LOCATION
@@ -184,5 +192,7 @@ target_link_libraries(  monerujo
                         ssl
                         crypto
 
+                        sodium
+
                        ${log-lib}
                        )

app/build.gradle

@@ -1,14 +1,15 @@
 apply plugin: 'com.android.application'
 
 android {
-    compileSdkVersion 25
-    buildToolsVersion '27.0.3'
+    compileSdkVersion 28
+    buildToolsVersion '28.0.3'
     defaultConfig {
         applicationId "com.m2049r.xmrwallet"
         minSdkVersion 21
-        targetSdkVersion 25
-        versionCode 97
-        versionName "1.5.7 'Maximum Nacho'"
+        targetSdkVersion 28
+        versionCode 157
+        versionName "1.10.7 'Node-O-matiC'"
+
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
         externalNativeBuild {
             cmake {
@@ -18,6 +19,26 @@ android {
         }
     }
 
+    flavorDimensions 'type', 'net'
+    productFlavors {
+        mainnet {
+            dimension 'net'
+        }
+        stagenet {
+            dimension 'net'
+            applicationIdSuffix '.stage'
+            versionNameSuffix ' (stage)'
+        }
+        alpha {
+            dimension 'type'
+            applicationIdSuffix '.alpha'
+            versionNameSuffix ' (alpha)'
+        }
+        prod {
+            dimension 'type'
+        }
+    }
+
     buildTypes {
         release {
             minifyEnabled false
@@ -27,6 +48,7 @@ android {
             applicationIdSuffix ".debug"
         }
     }
+
     externalNativeBuild {
         cmake {
             path "CMakeLists.txt"
@@ -45,34 +67,53 @@ android {
     // Map for the version code that gives each ABI a value.
     def abiCodes = ['armeabi-v7a': 1, 'arm64-v8a': 2, 'x86': 3, 'x86_64': 4]
 
+    // Enumerate translated locales
+    def availableLocales = ["en"]
+    new File("app/src/main/res/").eachFileMatch(~/^values-.*/) { file ->
+        def languageTag = file.name.substring(7).replace("-r", "-")
+        availableLocales.add(languageTag)
+    }
+
     // APKs for the same app that all have the same version information.
     android.applicationVariants.all { variant ->
+        // Update string resource: available_locales
+        variant.resValue("string", "available_locales", availableLocales.join(","))
         // Assigns a different version code for each output APK.
         variant.outputs.all {
             output ->
                 def abiName = output.getFilter(com.android.build.OutputFile.ABI)
                 output.versionCodeOverride = abiCodes.get(abiName, 0) + 10 * variant.versionCode
+                //def flavor = output.getFilter(flavor)
 
                 if (abiName == null) abiName = "universal"
-                def v = "${variant.versionName}".replaceFirst(" .*\$", "").replace(".", "x")
+                def v = "${variant.versionName}".replaceFirst(" '.*' ?", "")
+                        .replace(".", "x")
+                        .replace("(", "-")
+                        .replace(")", "")
                 outputFileName = "$rootProject.ext.apkName-" + v + "_" + abiName + ".apk"
         }
     }
 }
 
 dependencies {
-    implementation 'com.android.support:appcompat-v7:25.4.0'
-    implementation 'com.android.support:design:25.4.0'
-    implementation 'com.android.support:support-v4:25.4.0'
-    implementation 'com.android.support:recyclerview-v7:25.4.0'
-    implementation 'com.android.support:cardview-v7:25.4.0'
+    implementation "com.android.support:appcompat-v7:$rootProject.ext.supportVersion"
+    implementation "com.android.support:design:$rootProject.ext.supportVersion"
+    implementation "com.android.support:support-v4:$rootProject.ext.supportVersion"
+    implementation "com.android.support:recyclerview-v7:$rootProject.ext.supportVersion"
+    implementation "com.android.support:cardview-v7:$rootProject.ext.supportVersion"
+    implementation "com.android.support:swiperefreshlayout:$rootProject.ext.supportVersion"
     implementation 'me.dm7.barcodescanner:zxing:1.9.8'
 
     implementation "com.squareup.okhttp3:okhttp:$rootProject.ext.okHttpVersion"
+    implementation "com.burgstaller:okhttp-digest:1.18"
     implementation "com.jakewharton.timber:timber:$rootProject.ext.timberVersion"
 
     implementation 'com.nulab-inc:zxcvbn:1.2.3'
 
+    implementation 'dnsjava:dnsjava:2.1.8'
+    implementation 'org.jitsi:dnssecjava:1.1.3'
+    implementation 'org.slf4j:slf4j-nop:1.7.25'
+
     testImplementation "junit:junit:$rootProject.ext.junitVersion"
     testImplementation "org.mockito:mockito-all:$rootProject.ext.mockitoVersion"
     testImplementation "com.squareup.okhttp3:mockwebserver:$rootProject.ext.okHttpVersion"

app/src/debug/res/values/strings.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="app_name" translatable="false">monerujo - Debug</string>
-</resources>

app/src/main/AndroidManifest.xml

@@ -7,15 +7,19 @@
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />
     <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.USE_BIOMETRIC" />
     <uses-permission android:name="android.permission.USE_FINGERPRINT" />
+    <uses-permission android:name="android.permission.NFC" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
 
     <application
-        android:allowBackup="true"
+        android:name=".XmrWalletApplication"
+        android:allowBackup="false"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:supportsRtl="true"
-        android:name=".XmrWalletApplication"
-        android:theme="@style/MyMaterialTheme">
+        android:theme="@style/MyMaterialTheme"
+        android:usesCleartextTraffic="true">
 
         <activity
             android:name=".WalletActivity"
@@ -28,11 +32,19 @@
             android:name=".LoginActivity"
             android:configChanges="orientation|keyboardHidden"
             android:label="@string/app_name"
+            android:launchMode="singleTop"
             android:screenOrientation="portrait">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
+            <intent-filter>
+                <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" />
+            </intent-filter>
+
+            <meta-data
+                android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED"
+                android:resource="@xml/usb_device_filter" />
         </activity>
 
         <service
@@ -40,7 +52,5 @@
             android:description="@string/service_description"
             android:exported="false"
             android:label="Monero Wallet Service" />
-
     </application>
-
 </manifest>

app/src/main/cpp/device_io_monerujo.hpp

@@ -0,0 +1,88 @@
+// Copyright (c) 2017-2018, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+#if defined(HAVE_MONERUJO)
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+ * @brief LedgerFind - find Ledger Device and return it's name
+ * @param buffer     - buffer for name of found device
+ * @param len        - length of buffer
+ * @return  0 - success
+ *         -1 - no device connected / found
+ *         -2 - JVM not found
+ */
+int LedgerFind(char *buffer, size_t len);
+
+/**
+ * @brief LedgerExchange - exchange data with Ledger Device
+ * @param command        - buffer for data to send
+ * @param cmd_len        - length of send to send
+ * @param response       - buffer for received data
+ * @param max_resp_len   - size of receive buffer
+ *
+ * @return length of received data in response or -1 if error
+ */
+int  LedgerExchange(unsigned char *command, unsigned int cmd_len, unsigned char *response, unsigned int max_resp_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#include "device_io.hpp"
+
+#pragma once
+
+namespace hw {
+  namespace io {
+    class device_io_monerujo: device_io {
+    public:
+      device_io_monerujo() {};
+      ~device_io_monerujo() {};
+
+      void init() {};
+      void release() {};
+
+      void connect(void *params) {};
+      void disconnect() {};
+      bool connected() const {return true;}; // monerujo is always connected before it gets here
+
+      // returns number of bytes read or -1 on error
+      int  exchange(unsigned char *command, unsigned int cmd_len, unsigned char *response, unsigned int max_resp_len) {
+        return LedgerExchange(command, cmd_len, response, max_resp_len);
+      }
+    };
+  };
+};
+
+#endif //#if defined(HAVE_MONERUJO)

app/src/main/java/com/btchip/BTChipException.java

@@ -0,0 +1,53 @@
+/*
+ *******************************************************************************
+ *   BTChip Bitcoin Hardware Wallet Java API
+ *   (c) 2014 BTChip - 1BTChip7VfTnrPra5jqci7ejnMguuHogTn
+ *
+ *  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.
+ ********************************************************************************
+ */
+
+package com.btchip;
+
+public class BTChipException extends Exception {
+
+    private static final long serialVersionUID = 5512803003827126405L;
+
+    public BTChipException(String reason) {
+        super(reason);
+    }
+
+    public BTChipException(String reason, Throwable cause) {
+        super(reason, cause);
+    }
+
+    public BTChipException(String reason, int sw) {
+        super(reason);
+        this.sw = sw;
+    }
+
+    public int getSW() {
+        return sw;
+    }
+
+    public String toString() {
+        if (sw == 0) {
+            return "BTChip Exception : " + getMessage();
+        } else {
+            return "BTChip Exception : " + getMessage() + " " + Integer.toHexString(sw);
+        }
+    }
+
+    private int sw;
+
+}

app/src/main/java/com/btchip/comm/BTChipTransport.java

@@ -0,0 +1,31 @@
+/*
+ *******************************************************************************
+ *   BTChip Bitcoin Hardware Wallet Java API
+ *   (c) 2014 BTChip - 1BTChip7VfTnrPra5jqci7ejnMguuHogTn
+ *   (c) 2018 m2049r
+ *
+ *  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.
+ ********************************************************************************
+ */
+
+package com.btchip.comm;
+
+import com.btchip.BTChipException;
+
+public interface BTChipTransport {
+    byte[] exchange(byte[] command);
+
+    void close();
+
+    void setDebug(boolean debugFlag);
+}

app/src/main/java/com/btchip/comm/LedgerHelper.java

@@ -0,0 +1,126 @@
+/*
+ *******************************************************************************
+ *   BTChip Bitcoin Hardware Wallet Java API
+ *   (c) 2014 BTChip - 1BTChip7VfTnrPra5jqci7ejnMguuHogTn
+ *   (c) 2018 m2049r
+ *
+ *  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.
+ ********************************************************************************
+ */
+
+package com.btchip.comm;
+
+import java.io.ByteArrayOutputStream;
+
+public class LedgerHelper {
+
+    private static final int TAG_APDU = 0x05;
+
+    public static byte[] wrapCommandAPDU(int channel, byte[] command, int packetSize) {
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
+        if (packetSize < 3) {
+            throw new IllegalArgumentException("Can't handle Ledger framing with less than 3 bytes for the report");
+        }
+        int sequenceIdx = 0;
+        int offset = 0;
+        output.write(channel >> 8);
+        output.write(channel);
+        output.write(TAG_APDU);
+        output.write(sequenceIdx >> 8);
+        output.write(sequenceIdx);
+        sequenceIdx++;
+        output.write(command.length >> 8);
+        output.write(command.length);
+        int blockSize = (command.length > packetSize - 7 ? packetSize - 7 : command.length);
+        output.write(command, offset, blockSize);
+        offset += blockSize;
+        while (offset != command.length) {
+            output.write(channel >> 8);
+            output.write(channel);
+            output.write(TAG_APDU);
+            output.write(sequenceIdx >> 8);
+            output.write(sequenceIdx);
+            sequenceIdx++;
+            blockSize = (command.length - offset > packetSize - 5 ? packetSize - 5 : command.length - offset);
+            output.write(command, offset, blockSize);
+            offset += blockSize;
+        }
+        if ((output.size() % packetSize) != 0) {
+            byte[] padding = new byte[packetSize - (output.size() % packetSize)];
+            output.write(padding, 0, padding.length);
+        }
+        return output.toByteArray();
+    }
+
+    public static byte[] unwrapResponseAPDU(int channel, byte[] data, int packetSize) {
+        ByteArrayOutputStream response = new ByteArrayOutputStream();
+        int offset = 0;
+        int responseLength;
+        int sequenceIdx = 0;
+        if ((data == null) || (data.length < 7 + 5)) {
+            return null;
+        }
+        if (data[offset++] != (channel >> 8)) {
+            throw new IllegalArgumentException("Invalid channel");
+        }
+        if (data[offset++] != (channel & 0xff)) {
+            throw new IllegalArgumentException("Invalid channel");
+        }
+        if (data[offset++] != TAG_APDU) {
+            throw new IllegalArgumentException("Invalid tag");
+        }
+        if (data[offset++] != 0x00) {
+            throw new IllegalArgumentException("Invalid sequence");
+        }
+        if (data[offset++] != 0x00) {
+            throw new IllegalArgumentException("Invalid sequence");
+        }
+        responseLength = ((data[offset++] & 0xff) << 8);
+        responseLength |= (data[offset++] & 0xff);
+        if (data.length < 7 + responseLength) {
+            return null;
+        }
+        int blockSize = (responseLength > packetSize - 7 ? packetSize - 7 : responseLength);
+        response.write(data, offset, blockSize);
+        offset += blockSize;
+        while (response.size() != responseLength) {
+            sequenceIdx++;
+            if (offset == data.length) {
+                return null;
+            }
+            if (data[offset++] != (channel >> 8)) {
+                throw new IllegalArgumentException("Invalid channel");
+            }
+            if (data[offset++] != (channel & 0xff)) {
+                throw new IllegalArgumentException("Invalid channel");
+            }
+            if (data[offset++] != TAG_APDU) {
+                throw new IllegalArgumentException("Invalid tag");
+            }
+            if (data[offset++] != (sequenceIdx >> 8)) {
+                throw new IllegalArgumentException("Invalid sequence");
+            }
+            if (data[offset++] != (sequenceIdx & 0xff)) {
+                throw new IllegalArgumentException("Invalid sequence");
+            }
+            blockSize = (responseLength - response.size() > packetSize - 5 ? packetSize - 5 : responseLength - response.size());
+            if (blockSize > data.length - offset) {
+                return null;
+            }
+            response.write(data, offset, blockSize);
+            offset += blockSize;
+        }
+        return response.toByteArray();
+    }
+
+}

app/src/main/java/com/btchip/comm/android/BTChipTransportAndroidHID.java

@@ -0,0 +1,145 @@
+/*
+ *******************************************************************************
+ *   BTChip Bitcoin Hardware Wallet Java API
+ *   (c) 2014 BTChip - 1BTChip7VfTnrPra5jqci7ejnMguuHogTn
+ *   (c) 2018 m2049r
+ *
+ *  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.
+ ********************************************************************************
+ */
+
+package com.btchip.comm.android;
+
+import android.hardware.usb.UsbConstants;
+import android.hardware.usb.UsbDevice;
+import android.hardware.usb.UsbDeviceConnection;
+import android.hardware.usb.UsbEndpoint;
+import android.hardware.usb.UsbInterface;
+import android.hardware.usb.UsbManager;
+import android.hardware.usb.UsbRequest;
+
+import com.btchip.BTChipException;
+import com.btchip.comm.BTChipTransport;
+import com.btchip.comm.LedgerHelper;
+import com.btchip.utils.Dump;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+
+import timber.log.Timber;
+
+public class BTChipTransportAndroidHID implements BTChipTransport {
+
+    public static UsbDevice getDevice(UsbManager manager) {
+        HashMap<String, UsbDevice> deviceList = manager.getDeviceList();
+        for (UsbDevice device : deviceList.values()) {
+            Timber.d("%04X:%04X %s, %s", device.getVendorId(), device.getProductId(), device.getManufacturerName(), device.getProductName());
+            if ((device.getVendorId() == VID) && (device.getProductId() == PID_HID)) {
+                return device;
+            }
+        }
+        return null;
+    }
+
+    public static BTChipTransport open(UsbManager manager, UsbDevice device) throws IOException {
+        UsbDeviceConnection connection = manager.openDevice(device);
+        if (connection == null) throw new IOException("Device not connected");
+        // Must only be called once permission is granted (see http://developer.android.com/reference/android/hardware/usb/UsbManager.html)
+        // Important if enumerating, rather than being awaken by the intent notification
+        UsbInterface dongleInterface = device.getInterface(0);
+        UsbEndpoint in = null;
+        UsbEndpoint out = null;
+        for (int i = 0; i < dongleInterface.getEndpointCount(); i++) {
+            UsbEndpoint tmpEndpoint = dongleInterface.getEndpoint(i);
+            if (tmpEndpoint.getDirection() == UsbConstants.USB_DIR_IN) {
+                in = tmpEndpoint;
+            } else {
+                out = tmpEndpoint;
+            }
+        }
+        connection.claimInterface(dongleInterface, true);
+        return new BTChipTransportAndroidHID(connection, dongleInterface, in, out);
+    }
+
+    private static final int VID = 0x2C97;
+    private static final int PID_HID = 0x0001;
+
+    private UsbDeviceConnection connection;
+    private UsbInterface dongleInterface;
+    private UsbEndpoint in;
+    private UsbEndpoint out;
+    private byte transferBuffer[];
+    private boolean debug;
+
+    public BTChipTransportAndroidHID(UsbDeviceConnection connection, UsbInterface dongleInterface, UsbEndpoint in, UsbEndpoint out) {
+        this.connection = connection;
+        this.dongleInterface = dongleInterface;
+        this.in = in;
+        this.out = out;
+        transferBuffer = new byte[HID_BUFFER_SIZE];
+    }
+
+    @Override
+    public byte[] exchange(byte[] command) {
+        ByteArrayOutputStream response = new ByteArrayOutputStream();
+        byte[] responseData = null;
+        int offset = 0;
+        if (debug) {
+            Timber.d("=> %s", Dump.dump(command));
+        }
+        command = LedgerHelper.wrapCommandAPDU(LEDGER_DEFAULT_CHANNEL, command, HID_BUFFER_SIZE);
+        UsbRequest requestOut = new UsbRequest();
+        requestOut.initialize(connection, out);
+        while (offset != command.length) {
+            int blockSize = (command.length - offset > HID_BUFFER_SIZE ? HID_BUFFER_SIZE : command.length - offset);
+            System.arraycopy(command, offset, transferBuffer, 0, blockSize);
+            requestOut.queue(ByteBuffer.wrap(transferBuffer), HID_BUFFER_SIZE);
+            connection.requestWait();
+            offset += blockSize;
+        }
+        requestOut.close();
+        ByteBuffer responseBuffer = ByteBuffer.allocate(HID_BUFFER_SIZE);
+        UsbRequest requestIn = new UsbRequest();
+        requestIn.initialize(connection, in);
+        while ((responseData = LedgerHelper.unwrapResponseAPDU(LEDGER_DEFAULT_CHANNEL, response.toByteArray(), HID_BUFFER_SIZE)) == null) {
+            responseBuffer.clear();
+            requestIn.queue(responseBuffer, HID_BUFFER_SIZE);
+            connection.requestWait();
+            responseBuffer.rewind();
+            responseBuffer.get(transferBuffer, 0, HID_BUFFER_SIZE);
+            response.write(transferBuffer, 0, HID_BUFFER_SIZE);
+        }
+        requestIn.close();
+        if (debug) {
+            Timber.d("<= %s", Dump.dump(responseData));
+        }
+        return responseData;
+    }
+
+    @Override
+    public void close() {
+        connection.releaseInterface(dongleInterface);
+        connection.close();
+    }
+
+    @Override
+    public void setDebug(boolean debugFlag) {
+        this.debug = debugFlag;
+    }
+
+    private static final int HID_BUFFER_SIZE = 64;
+    private static final int LEDGER_DEFAULT_CHANNEL = 1;
+    private static final int SW1_DATA_AVAILABLE = 0x61;
+}

app/src/main/java/com/btchip/utils/Dump.java

@@ -0,0 +1,62 @@
+/*
+ *******************************************************************************
+ *   BTChip Bitcoin Hardware Wallet Java API
+ *   (c) 2014 BTChip - 1BTChip7VfTnrPra5jqci7ejnMguuHogTn
+ *
+ *  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.
+ ********************************************************************************
+ */
+
+package com.btchip.utils;
+
+import java.io.ByteArrayOutputStream;
+
+public class Dump {
+
+    public static String dump(byte[] buffer, int offset, int length) {
+        String result = "";
+        for (int i = 0; i < length; i++) {
+            String temp = Integer.toHexString((buffer[offset + i]) & 0xff);
+            if (temp.length() < 2) {
+                temp = "0" + temp;
+            }
+            result += temp;
+        }
+        return result;
+    }
+
+    public static String dump(byte[] buffer) {
+        return dump(buffer, 0, buffer.length);
+    }
+
+    public static byte[] hexToBin(String src) {
+        ByteArrayOutputStream result = new ByteArrayOutputStream();
+        int i = 0;
+        while (i < src.length()) {
+            char x = src.charAt(i);
+            if (!((x >= '0' && x <= '9') || (x >= 'A' && x <= 'F') || (x >= 'a' && x <= 'f'))) {
+                i++;
+                continue;
+            }
+            try {
+                result.write(Integer.valueOf("" + src.charAt(i) + src.charAt(i + 1), 16));
+                i += 2;
+            } catch (Exception e) {
+                return null;
+            }
+        }
+        return result.toByteArray();
+    }
+
+
+}

app/src/main/java/com/m2049r/levin/data/Bucket.java

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2018 m2049r
+ *
+ * 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.
+ */
+
+package com.m2049r.levin.data;
+
+import com.m2049r.levin.util.HexHelper;
+import com.m2049r.levin.util.LevinReader;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public class Bucket {
+
+    // constants copied from monero p2p & epee
+
+    public final static int P2P_COMMANDS_POOL_BASE = 1000;
+    public final static int COMMAND_HANDSHAKE_ID = P2P_COMMANDS_POOL_BASE + 1;
+    public final static int COMMAND_TIMED_SYNC_ID = P2P_COMMANDS_POOL_BASE + 2;
+    public final static int COMMAND_PING_ID = P2P_COMMANDS_POOL_BASE + 3;
+    public final static int COMMAND_REQUEST_STAT_INFO_ID = P2P_COMMANDS_POOL_BASE + 4;
+    public final static int COMMAND_REQUEST_NETWORK_STATE_ID = P2P_COMMANDS_POOL_BASE + 5;
+    public final static int COMMAND_REQUEST_PEER_ID_ID = P2P_COMMANDS_POOL_BASE + 6;
+    public final static int COMMAND_REQUEST_SUPPORT_FLAGS_ID = P2P_COMMANDS_POOL_BASE + 7;
+
+    public final static long LEVIN_SIGNATURE = 0x0101010101012101L; // Bender's nightmare
+
+    public final static long LEVIN_DEFAULT_MAX_PACKET_SIZE = 100000000; // 100MB by default
+
+    public final static int LEVIN_PACKET_REQUEST = 0x00000001;
+    public final static int LEVIN_PACKET_RESPONSE = 0x00000002;
+
+    public final static int LEVIN_PROTOCOL_VER_0 = 0;
+    public final static int LEVIN_PROTOCOL_VER_1 = 1;
+
+    public final static int LEVIN_OK = 0;
+    public final static int LEVIN_ERROR_CONNECTION = -1;
+    public final static int LEVIN_ERROR_CONNECTION_NOT_FOUND = -2;
+    public final static int LEVIN_ERROR_CONNECTION_DESTROYED = -3;
+    public final static int LEVIN_ERROR_CONNECTION_TIMEDOUT = -4;
+    public final static int LEVIN_ERROR_CONNECTION_NO_DUPLEX_PROTOCOL = -5;
+    public final static int LEVIN_ERROR_CONNECTION_HANDLER_NOT_DEFINED = -6;
+    public final static int LEVIN_ERROR_FORMAT = -7;
+
+    public final static int P2P_SUPPORT_FLAG_FLUFFY_BLOCKS = 0x01;
+    public final static int P2P_SUPPORT_FLAGS = P2P_SUPPORT_FLAG_FLUFFY_BLOCKS;
+
+    final private long signature;
+    final private long cb;
+    final public boolean haveToReturnData;
+    final public int command;
+    final public int returnCode;
+    final private int flags;
+    final private int protcolVersion;
+    final byte[] payload;
+
+    final public Section payloadSection;
+
+    // create a request
+    public Bucket(int command, byte[] payload) throws IOException {
+        this.signature = LEVIN_SIGNATURE;
+        this.cb = payload.length;
+        this.haveToReturnData = true;
+        this.command = command;
+        this.returnCode = 0;
+        this.flags = LEVIN_PACKET_REQUEST;
+        this.protcolVersion = LEVIN_PROTOCOL_VER_1;
+        this.payload = payload;
+        payloadSection = LevinReader.readPayload(payload);
+    }
+
+    // create a response
+    public Bucket(int command, byte[] payload, int rc) throws IOException {
+        this.signature = LEVIN_SIGNATURE;
+        this.cb = payload.length;
+        this.haveToReturnData = false;
+        this.command = command;
+        this.returnCode = rc;
+        this.flags = LEVIN_PACKET_RESPONSE;
+        this.protcolVersion = LEVIN_PROTOCOL_VER_1;
+        this.payload = payload;
+        payloadSection = LevinReader.readPayload(payload);
+    }
+
+    public Bucket(DataInput in) throws IOException {
+        signature = in.readLong();
+        cb = in.readLong();
+        haveToReturnData = in.readBoolean();
+        command = in.readInt();
+        returnCode = in.readInt();
+        flags = in.readInt();
+        protcolVersion = in.readInt();
+
+        if (signature == Bucket.LEVIN_SIGNATURE) {
+            if (cb > Integer.MAX_VALUE)
+                throw new IllegalArgumentException();
+            payload = new byte[(int) cb];
+            in.readFully(payload);
+        } else
+            throw new IllegalStateException();
+        payloadSection = LevinReader.readPayload(payload);
+    }
+
+    public Section getPayloadSection() {
+        return payloadSection;
+    }
+
+    public void send(DataOutput out) throws IOException {
+        out.writeLong(signature);
+        out.writeLong(cb);
+        out.writeBoolean(haveToReturnData);
+        out.writeInt(command);
+        out.writeInt(returnCode);
+        out.writeInt(flags);
+        out.writeInt(protcolVersion);
+        out.write(payload);
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("sig:  ").append(signature).append("\n");
+        sb.append("cb:   ").append(cb).append("\n");
+        sb.append("call: ").append(haveToReturnData).append("\n");
+        sb.append("cmd:  ").append(command).append("\n");
+        sb.append("rc:   ").append(returnCode).append("\n");
+        sb.append("flags:").append(flags).append("\n");
+        sb.append("proto:").append(protcolVersion).append("\n");
+        sb.append(HexHelper.bytesToHex(payload)).append("\n");
+        sb.append(payloadSection.toString());
+        return sb.toString();
+    }
+}

app/src/main/java/com/m2049r/levin/data/Section.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2018 m2049r
+ *
+ * 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.
+ */
+
+package com.m2049r.levin.data;
+
+import com.m2049r.levin.util.HexHelper;
+import com.m2049r.levin.util.LevinReader;
+import com.m2049r.levin.util.LevinWriter;
+import com.m2049r.levin.util.LittleEndianDataOutputStream;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class Section {
+
+    // constants copied from monero p2p & epee
+
+    static final public int PORTABLE_STORAGE_SIGNATUREA = 0x01011101;
+    static final public int PORTABLE_STORAGE_SIGNATUREB = 0x01020101;
+
+    static final public byte PORTABLE_STORAGE_FORMAT_VER = 1;
+
+    static final public byte PORTABLE_RAW_SIZE_MARK_MASK = 0x03;
+    static final public byte PORTABLE_RAW_SIZE_MARK_BYTE = 0;
+    static final public byte PORTABLE_RAW_SIZE_MARK_WORD = 1;
+    static final public byte PORTABLE_RAW_SIZE_MARK_DWORD = 2;
+    static final public byte PORTABLE_RAW_SIZE_MARK_INT64 = 3;
+
+    static final long MAX_STRING_LEN_POSSIBLE = 2000000000; // do not let string be so big
+
+    // data types
+    static final public byte SERIALIZE_TYPE_INT64 = 1;
+    static final public byte SERIALIZE_TYPE_INT32 = 2;
+    static final public byte SERIALIZE_TYPE_INT16 = 3;
+    static final public byte SERIALIZE_TYPE_INT8 = 4;
+    static final public byte SERIALIZE_TYPE_UINT64 = 5;
+    static final public byte SERIALIZE_TYPE_UINT32 = 6;
+    static final public byte SERIALIZE_TYPE_UINT16 = 7;
+    static final public byte SERIALIZE_TYPE_UINT8 = 8;
+    static final public byte SERIALIZE_TYPE_DUOBLE = 9;
+    static final public byte SERIALIZE_TYPE_STRING = 10;
+    static final public byte SERIALIZE_TYPE_BOOL = 11;
+    static final public byte SERIALIZE_TYPE_OBJECT = 12;
+    static final public byte SERIALIZE_TYPE_ARRAY = 13;
+
+    static final public byte SERIALIZE_FLAG_ARRAY = (byte) 0x80;
+
+    private final Map<String, Object> entries = new HashMap<String, Object>();
+
+    public void add(String key, Object entry) {
+        entries.put(key, entry);
+    }
+
+    public int size() {
+        return entries.size();
+    }
+
+    public Set<Map.Entry<String, Object>> entrySet() {
+        return entries.entrySet();
+    }
+
+    public Object get(String key) {
+        return entries.get(key);
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        sb.append("\n");
+        for (Map.Entry<String, Object> entry : entries.entrySet()) {
+            sb.append(entry.getKey()).append("=");
+            final Object value = entry.getValue();
+            if (value instanceof List) {
+                @SuppressWarnings("unchecked") final List<Object> list = (List<Object>) value;
+                for (Object listEntry : list) {
+                    sb.append(listEntry.toString()).append("\n");
+                }
+            } else if (value instanceof String) {
+                sb.append("(").append(value).append(")\n");
+            } else if (value instanceof byte[]) {
+                sb.append(HexHelper.bytesToHex((byte[]) value)).append("\n");
+            } else {
+                sb.append(value.toString()).append("\n");
+            }
+        }
+        return sb.toString();
+    }
+
+    static public Section fromByteArray(byte[] buffer) {
+        try {
+            return LevinReader.readPayload(buffer);
+        } catch (IOException ex) {
+            throw new IllegalStateException();
+        }
+    }
+
+    public byte[] asByteArray() {
+        try {
+            ByteArrayOutputStream bas = new ByteArrayOutputStream();
+            DataOutput out = new LittleEndianDataOutputStream(bas);
+            LevinWriter writer = new LevinWriter(out);
+            writer.writePayload(this);
+            return bas.toByteArray();
+        } catch (IOException ex) {
+            throw new IllegalStateException();
+        }
+    }
+}

app/src/main/java/com/m2049r/levin/scanner/Dispatcher.java

@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2018 m2049r
+ *
+ * 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.
+ */
+
+package com.m2049r.levin.scanner;
+
+import com.m2049r.xmrwallet.data.NodeInfo;
+
+import java.net.InetSocketAddress;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+import timber.log.Timber;
+
+public class Dispatcher implements PeerRetriever.OnGetPeers {
+    static final public int NUM_THREADS = 50;
+    static final public int MAX_PEERS = 1000;
+    static final public long MAX_TIME = 30000000000L; //30 seconds
+
+    private int peerCount = 0;
+    final private Set<NodeInfo> knownNodes = new HashSet<>(); // set of nodes to test
+    final private Set<NodeInfo> rpcNodes = new HashSet<>(); // set of RPC nodes we like
+    final private ExecutorService exeService = Executors.newFixedThreadPool(NUM_THREADS);
+
+    public interface Listener {
+        void onGet(NodeInfo nodeInfo);
+    }
+
+    private Listener listener;
+
+    public Dispatcher(Listener listener) {
+        this.listener = listener;
+    }
+
+    public Set<NodeInfo> getRpcNodes() {
+        return rpcNodes;
+    }
+
+    public int getPeerCount() {
+        return peerCount;
+    }
+
+    public boolean getMorePeers() {
+        return peerCount < MAX_PEERS;
+    }
+
+    public void awaitTermination(int nodesToFind) {
+        try {
+            final long t = System.nanoTime();
+            while (!jobs.isEmpty()) {
+                try {
+                    Timber.d("Remaining jobs %d", jobs.size());
+                    final PeerRetriever retrievedPeer = jobs.poll().get();
+                    if (retrievedPeer.isGood() && getMorePeers())
+                        retrievePeers(retrievedPeer);
+                    final NodeInfo nodeInfo = retrievedPeer.getNodeInfo();
+                    Timber.d("Retrieved %s", nodeInfo);
+                    if ((nodeInfo.isValid() || nodeInfo.isFavourite())) {
+                        nodeInfo.setName();
+                        rpcNodes.add(nodeInfo);
+                        Timber.d("RPC: %s", nodeInfo);
+                        // the following is not totally correct but it works (otherwise we need to
+                        // load much more before filtering - but we don't have time
+                        if (listener != null) listener.onGet(nodeInfo);
+                        if (rpcNodes.size() >= nodesToFind) {
+                            Timber.d("are we done here?");
+                            filterRpcNodes();
+                            if (rpcNodes.size() >= nodesToFind) {
+                                Timber.d("we're done here");
+                                break;
+                            }
+                        }
+                    }
+                    if (System.nanoTime() - t > MAX_TIME) break; // watchdog
+                } catch (ExecutionException ex) {
+                    Timber.d(ex); // tell us about it and continue
+                }
+            }
+        } catch (InterruptedException ex) {
+            Timber.d(ex);
+        } finally {
+            Timber.d("Shutting down!");
+            exeService.shutdownNow();
+            try {
+                exeService.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
+            } catch (InterruptedException ex) {
+                Timber.d(ex);
+            }
+        }
+        filterRpcNodes();
+    }
+
+    static final public int HEIGHT_WINDOW = 1;
+
+    private boolean testHeight(long height, long consensus) {
+        return (height >= (consensus - HEIGHT_WINDOW))
+                && (height <= (consensus + HEIGHT_WINDOW));
+    }
+
+    private long calcConsensusHeight() {
+        Timber.d("Calc Consensus height from %d nodes", rpcNodes.size());
+        final Map<Long, Integer> nodeHeights = new TreeMap<Long, Integer>();
+        for (NodeInfo info : rpcNodes) {
+            if (!info.isValid()) continue;
+            Integer h = nodeHeights.get(info.getHeight());
+            if (h == null)
+                h = 0;
+            nodeHeights.put(info.getHeight(), h + 1);
+        }
+        long consensusHeight = 0;
+        long consensusCount = 0;
+        for (Map.Entry<Long, Integer> entry : nodeHeights.entrySet()) {
+            final long entryHeight = entry.getKey();
+            int count = 0;
+            for (long i = entryHeight - HEIGHT_WINDOW; i <= entryHeight + HEIGHT_WINDOW; i++) {
+                Integer v = nodeHeights.get(i);
+                if (v == null)
+                    v = 0;
+                count += v;
+            }
+            if (count >= consensusCount) {
+                consensusCount = count;
+                consensusHeight = entryHeight;
+            }
+            Timber.d("%d - %d/%d", entryHeight, count, entry.getValue());
+        }
+        return consensusHeight;
+    }
+
+    private void filterRpcNodes() {
+        long consensus = calcConsensusHeight();
+        Timber.d("Consensus Height = %d for %d nodes", consensus, rpcNodes.size());
+        for (Iterator<NodeInfo> iter = rpcNodes.iterator(); iter.hasNext(); ) {
+            NodeInfo info = iter.next();
+            // don't remove favourites
+            if (!info.isFavourite()) {
+                if (!testHeight(info.getHeight(), consensus)) {
+                    iter.remove();
+                    Timber.d("Removed %s", info);
+                }
+            }
+        }
+    }
+
+    // TODO: does this NEED to be a ConcurrentLinkedDeque?
+    private ConcurrentLinkedDeque<Future<PeerRetriever>> jobs = new ConcurrentLinkedDeque<>();
+
+    private void retrievePeer(NodeInfo nodeInfo) {
+        if (knownNodes.add(nodeInfo)) {
+            Timber.d("\t%d:%s", knownNodes.size(), nodeInfo);
+            jobs.add(exeService.submit(new PeerRetriever(nodeInfo, this)));
+            peerCount++; // jobs.size() does not perform well
+        }
+    }
+
+    private void retrievePeers(PeerRetriever peer) {
+        for (InetSocketAddress socketAddress : peer.getPeers()) {
+            if (getMorePeers())
+                retrievePeer(new NodeInfo(socketAddress));
+            else
+                break;
+        }
+    }
+
+    public void seedPeers(Collection<NodeInfo> seedNodes) {
+        for (NodeInfo node : seedNodes) {
+            node.clear();
+            if (node.isFavourite()) {
+                rpcNodes.add(node);
+                if (listener != null) listener.onGet(node);
+            }
+            retrievePeer(node);
+        }
+    }
+}

app/src/main/java/com/m2049r/levin/scanner/PeerRetriever.java

@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 2018 m2049r
+ *
+ * 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.
+ */
+
+package com.m2049r.levin.scanner;
+
+import com.m2049r.levin.data.Bucket;
+import com.m2049r.levin.data.Section;
+import com.m2049r.levin.util.HexHelper;
+import com.m2049r.levin.util.LittleEndianDataInputStream;
+import com.m2049r.levin.util.LittleEndianDataOutputStream;
+import com.m2049r.xmrwallet.data.NodeInfo;
+import com.m2049r.xmrwallet.util.Helper;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.Callable;
+
+import timber.log.Timber;
+
+public class PeerRetriever implements Callable<PeerRetriever> {
+    static final public int CONNECT_TIMEOUT = 500; //ms
+    static final public int SOCKET_TIMEOUT = 500; //ms
+    static final public long PEER_ID = new Random().nextLong();
+    static final private byte[] HANDSHAKE = handshakeRequest().asByteArray();
+    static final private byte[] FLAGS_RESP = flagsResponse().asByteArray();
+
+    final private List<InetSocketAddress> peers = new ArrayList<>();
+
+    private NodeInfo nodeInfo;
+    private OnGetPeers onGetPeersCallback;
+
+    public interface OnGetPeers {
+        boolean getMorePeers();
+    }
+
+    public PeerRetriever(NodeInfo nodeInfo, OnGetPeers onGetPeers) {
+        this.nodeInfo = nodeInfo;
+        this.onGetPeersCallback = onGetPeers;
+    }
+
+    public NodeInfo getNodeInfo() {
+        return nodeInfo;
+    }
+
+    public boolean isGood() {
+        return !peers.isEmpty();
+    }
+
+    public List<InetSocketAddress> getPeers() {
+        return peers;
+    }
+
+    public PeerRetriever call() {
+        if (isGood()) // we have already been called?
+            throw new IllegalStateException();
+        // first check for an rpc service
+        nodeInfo.findRpcService();
+        if (onGetPeersCallback.getMorePeers())
+            try {
+                Timber.d("%s CONN", nodeInfo.getLevinSocketAddress());
+                if (!connect())
+                    return this;
+                Bucket handshakeBucket = new Bucket(Bucket.COMMAND_HANDSHAKE_ID, HANDSHAKE);
+                handshakeBucket.send(getDataOutput());
+
+                while (true) {// wait for response (which may never come)
+                    Bucket recv = new Bucket(getDataInput()); // times out after SOCKET_TIMEOUT
+                    if ((recv.command == Bucket.COMMAND_HANDSHAKE_ID)
+                            && (!recv.haveToReturnData)) {
+                        readAddressList(recv.payloadSection);
+                        return this;
+                    } else if ((recv.command == Bucket.COMMAND_REQUEST_SUPPORT_FLAGS_ID)
+                            && (recv.haveToReturnData)) {
+                        Bucket flagsBucket = new Bucket(Bucket.COMMAND_REQUEST_SUPPORT_FLAGS_ID, FLAGS_RESP, 1);
+                        flagsBucket.send(getDataOutput());
+                    } else {// and ignore others
+                        Timber.d("Ignored LEVIN COMMAND %d", recv.command);
+                    }
+                }
+            } catch (IOException ex) {
+            } finally {
+                disconnect(); // we have what we want - byebye
+                Timber.d("%s DISCONN", nodeInfo.getLevinSocketAddress());
+            }
+        return this;
+    }
+
+    private void readAddressList(Section section) {
+        @SuppressWarnings("unchecked")
+        List<Section> peerList = (List<Section>) section.get("local_peerlist_new");
+        if (peerList != null) {
+            for (Section peer : peerList) {
+                Section adr = (Section) peer.get("adr");
+                Byte type = (Byte) adr.get("type");
+                if ((type == null) || (type != 1))
+                    continue;
+                Section addr = (Section) adr.get("addr");
+                if (addr == null)
+                    continue;
+                Integer ip = (Integer) addr.get("m_ip");
+                if (ip == null)
+                    continue;
+                Short sport = (Short) addr.get("m_port");
+                if (sport == null)
+                    continue;
+                int port = sport;
+                if (port < 0) // port is unsigned
+                    port = port + 0x10000;
+                InetAddress inet = HexHelper.toInetAddress(ip);
+                // make sure this is an address we want to talk to (i.e. a remote address)
+                if (!inet.isSiteLocalAddress() && !inet.isAnyLocalAddress()
+                        && !inet.isLoopbackAddress()
+                        && !inet.isMulticastAddress()
+                        && !inet.isLinkLocalAddress()) {
+                    peers.add(new InetSocketAddress(inet, port));
+                }
+            }
+        }
+    }
+
+    private Socket socket = null;
+
+    private boolean connect() {
+        if (socket != null) throw new IllegalStateException();
+        try {
+            socket = new Socket();
+            socket.connect(nodeInfo.getLevinSocketAddress(), CONNECT_TIMEOUT);
+            socket.setSoTimeout(SOCKET_TIMEOUT);
+        } catch (IOException ex) {
+            //Timber.d(ex);
+            return false;
+        }
+        return true;
+    }
+
+    private boolean isConnected() {
+        return socket.isConnected();
+    }
+
+    private void disconnect() {
+        try {
+            dataInput = null;
+            dataOutput = null;
+            if ((socket != null) && (!socket.isClosed())) {
+                socket.close();
+            }
+        } catch (IOException ex) {
+            Timber.d(ex);
+        } finally {
+            socket = null;
+        }
+    }
+
+    private DataOutput dataOutput = null;
+
+    private DataOutput getDataOutput() throws IOException {
+        if (dataOutput == null)
+            synchronized (this) {
+                if (dataOutput == null)
+                    dataOutput = new LittleEndianDataOutputStream(
+                            socket.getOutputStream());
+            }
+        return dataOutput;
+    }
+
+    private DataInput dataInput = null;
+
+    private DataInput getDataInput() throws IOException {
+        if (dataInput == null)
+            synchronized (this) {
+                if (dataInput == null)
+                    dataInput = new LittleEndianDataInputStream(
+                            socket.getInputStream());
+            }
+        return dataInput;
+    }
+
+    static private Section handshakeRequest() {
+        Section section = new Section(); // root object
+
+        Section nodeData = new Section();
+        nodeData.add("local_time", (new Date()).getTime());
+        nodeData.add("my_port", 0);
+        byte[] networkId = Helper.hexToBytes("1230f171610441611731008216a1a110"); // mainnet
+        nodeData.add("network_id", networkId);
+        nodeData.add("peer_id", PEER_ID);
+        section.add("node_data", nodeData);
+
+        Section payloadData = new Section();
+        payloadData.add("cumulative_difficulty", 1L);
+        payloadData.add("current_height", 1L);
+        byte[] genesisHash =
+                Helper.hexToBytes("418015bb9ae982a1975da7d79277c2705727a56894ba0fb246adaabb1f4632e3");
+        payloadData.add("top_id", genesisHash);
+        payloadData.add("top_version", (byte) 1);
+        section.add("payload_data", payloadData);
+        return section;
+    }
+
+    static private Section flagsResponse() {
+        Section section = new Section(); // root object
+        section.add("support_flags", Bucket.P2P_SUPPORT_FLAGS);
+        return section;
+    }
+}

app/src/main/java/com/m2049r/levin/util/HexHelper.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2018 m2049r
+ *
+ * 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.
+ */
+
+package com.m2049r.levin.util;
+
+import java.math.BigInteger;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+public class HexHelper {
+
+    static public String bytesToHex(byte[] data) {
+        if ((data != null) && (data.length > 0))
+            return String.format("%0" + (data.length * 2) + "X",
+                    new BigInteger(1, data));
+        else
+            return "";
+    }
+
+    static public InetAddress toInetAddress(int ip) {
+        try {
+            String ipAddress = String.format("%d.%d.%d.%d", (ip & 0xff),
+                    (ip >> 8 & 0xff), (ip >> 16 & 0xff), (ip >> 24 & 0xff));
+            return InetAddress.getByName(ipAddress);
+        } catch (UnknownHostException ex) {
+            throw new IllegalArgumentException(ex);
+        }
+    }
+}

app/src/main/java/com/m2049r/levin/util/LevinReader.java

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2018 m2049r
+ *
+ * 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.
+ */
+
+package com.m2049r.levin.util;
+
+import com.m2049r.levin.data.Section;
+
+import java.io.ByteArrayInputStream;
+import java.io.DataInput;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+// Full Levin reader as seen on epee
+
+public class LevinReader {
+    private DataInput in;
+
+    private LevinReader(byte[] buffer) {
+        ByteArrayInputStream bis = new ByteArrayInputStream(buffer);
+        in = new LittleEndianDataInputStream(bis);
+    }
+
+    static public Section readPayload(byte[] payload) throws IOException {
+        LevinReader r = new LevinReader(payload);
+        return r.readPayload();
+    }
+
+    private Section readPayload() throws IOException {
+        if (in.readInt() != Section.PORTABLE_STORAGE_SIGNATUREA)
+            throw new IllegalStateException();
+        if (in.readInt() != Section.PORTABLE_STORAGE_SIGNATUREB)
+            throw new IllegalStateException();
+        if (in.readByte() != Section.PORTABLE_STORAGE_FORMAT_VER)
+            throw new IllegalStateException();
+        return readSection();
+    }
+
+    private Section readSection() throws IOException {
+        Section section = new Section();
+        long count = readVarint();
+        while (count-- > 0) {
+            // read section name string
+            String sectionName = readSectionName();
+            section.add(sectionName, loadStorageEntry());
+        }
+        return section;
+    }
+
+    private Object loadStorageArrayEntry(int type) throws IOException {
+        type &= ~Section.SERIALIZE_FLAG_ARRAY;
+        return readArrayEntry(type);
+    }
+
+    private List<Object> readArrayEntry(int type) throws IOException {
+        List<Object> list = new ArrayList<Object>();
+        long size = readVarint();
+        while (size-- > 0)
+            list.add(read(type));
+        return list;
+    }
+
+    private Object read(int type) throws IOException {
+        switch (type) {
+            case Section.SERIALIZE_TYPE_UINT64:
+            case Section.SERIALIZE_TYPE_INT64:
+                return in.readLong();
+            case Section.SERIALIZE_TYPE_UINT32:
+            case Section.SERIALIZE_TYPE_INT32:
+                return in.readInt();
+            case Section.SERIALIZE_TYPE_UINT16:
+            case Section.SERIALIZE_TYPE_INT16:
+                return in.readShort();
+            case Section.SERIALIZE_TYPE_UINT8:
+            case Section.SERIALIZE_TYPE_INT8:
+                return in.readByte();
+            case Section.SERIALIZE_TYPE_OBJECT:
+                return readSection();
+            case Section.SERIALIZE_TYPE_STRING:
+                return readByteArray();
+            default:
+                throw new IllegalArgumentException("type " + type
+                        + " not supported");
+        }
+    }
+
+    private Object loadStorageEntry() throws IOException {
+        int type = in.readUnsignedByte();
+        if ((type & Section.SERIALIZE_FLAG_ARRAY) != 0)
+            return loadStorageArrayEntry(type);
+        if (type == Section.SERIALIZE_TYPE_ARRAY)
+            return readStorageEntryArrayEntry();
+        else
+            return readStorageEntry(type);
+    }
+
+    private Object readStorageEntry(int type) throws IOException {
+        return read(type);
+    }
+
+    private Object readStorageEntryArrayEntry() throws IOException {
+        int type = in.readUnsignedByte();
+        if ((type & Section.SERIALIZE_FLAG_ARRAY) != 0)
+            throw new IllegalStateException("wrong type sequences");
+        return loadStorageArrayEntry(type);
+    }
+
+    private String readSectionName() throws IOException {
+        int nameLen = in.readUnsignedByte();
+        return readString(nameLen);
+    }
+
+    private byte[] read(long count) throws IOException {
+        if (count > Integer.MAX_VALUE)
+            throw new IllegalArgumentException();
+        int len = (int) count;
+        final byte buffer[] = new byte[len];
+        in.readFully(buffer);
+        return buffer;
+    }
+
+    private String readString(long count) throws IOException {
+        return new String(read(count), StandardCharsets.US_ASCII);
+    }
+
+    private byte[] readByteArray(long count) throws IOException {
+        return read(count);
+    }
+
+    private byte[] readByteArray() throws IOException {
+        long len = readVarint();
+        return readByteArray(len);
+    }
+
+    private long readVarint() throws IOException {
+        long v = 0;
+        int b = in.readUnsignedByte();
+        int sizeMask = b & Section.PORTABLE_RAW_SIZE_MARK_MASK;
+        switch (sizeMask) {
+            case Section.PORTABLE_RAW_SIZE_MARK_BYTE:
+                v = b >>> 2;
+                break;
+            case Section.PORTABLE_RAW_SIZE_MARK_WORD:
+                v = readRest(b, 1) >>> 2;
+                break;
+            case Section.PORTABLE_RAW_SIZE_MARK_DWORD:
+                v = readRest(b, 3) >>> 2;
+                break;
+            case Section.PORTABLE_RAW_SIZE_MARK_INT64:
+                v = readRest(b, 7) >>> 2;
+                break;
+            default:
+                throw new IllegalStateException();
+        }
+        return v;
+    }
+
+    // this should be in LittleEndianDataInputStream because it has little
+    // endian logic
+    private long readRest(int firstByte, int bytes) throws IOException {
+        long result = firstByte;
+        for (int i = 0; i < bytes; i++) {
+            result = result + (in.readUnsignedByte() << 8);
+        }
+        return result;
+    }
+
+}

app/src/main/java/com/m2049r/levin/util/LevinWriter.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2018 m2049r
+ *
+ * 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.
+ */
+
+package com.m2049r.levin.util;
+
+import com.m2049r.levin.data.Section;
+
+import java.io.DataOutput;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+
+// a simplified Levin Writer WITHOUT support for arrays
+
+public class LevinWriter {
+    private DataOutput out;
+
+    public LevinWriter(DataOutput out) {
+        this.out = out;
+    }
+
+    public void writePayload(Section section) throws IOException {
+        out.writeInt(Section.PORTABLE_STORAGE_SIGNATUREA);
+        out.writeInt(Section.PORTABLE_STORAGE_SIGNATUREB);
+        out.writeByte(Section.PORTABLE_STORAGE_FORMAT_VER);
+        putSection(section);
+    }
+
+    private void writeSection(Section section) throws IOException {
+        out.writeByte(Section.SERIALIZE_TYPE_OBJECT);
+        putSection(section);
+    }
+
+    private void putSection(Section section) throws IOException {
+        writeVarint(section.size());
+        for (Map.Entry<String, Object> kv : section.entrySet()) {
+            byte[] key = kv.getKey().getBytes(StandardCharsets.US_ASCII);
+            out.writeByte(key.length);
+            out.write(key);
+            write(kv.getValue());
+        }
+    }
+
+    private void writeVarint(long i) throws IOException {
+        if (i <= 63) {
+            out.writeByte(((int) i << 2) | Section.PORTABLE_RAW_SIZE_MARK_BYTE);
+        } else if (i <= 16383) {
+            out.writeShort(((int) i << 2) | Section.PORTABLE_RAW_SIZE_MARK_WORD);
+        } else if (i <= 1073741823) {
+            out.writeInt(((int) i << 2) | Section.PORTABLE_RAW_SIZE_MARK_DWORD);
+        } else {
+            if (i > 4611686018427387903L)
+                throw new IllegalArgumentException();
+            out.writeLong((i << 2) | Section.PORTABLE_RAW_SIZE_MARK_INT64);
+        }
+    }
+
+    private void write(Object object) throws IOException {
+        if (object instanceof byte[]) {
+            byte[] value = (byte[]) object;
+            out.writeByte(Section.SERIALIZE_TYPE_STRING);
+            writeVarint(value.length);
+            out.write(value);
+        } else if (object instanceof String) {
+            byte[] value = ((String) object)
+                    .getBytes(StandardCharsets.US_ASCII);
+            out.writeByte(Section.SERIALIZE_TYPE_STRING);
+            writeVarint(value.length);
+            out.write(value);
+        } else if (object instanceof Integer) {
+            out.writeByte(Section.SERIALIZE_TYPE_UINT32);
+            out.writeInt((int) object);
+        } else if (object instanceof Long) {
+            out.writeByte(Section.SERIALIZE_TYPE_UINT64);
+            out.writeLong((long) object);
+        } else if (object instanceof Byte) {
+            out.writeByte(Section.SERIALIZE_TYPE_UINT8);
+            out.writeByte((byte) object);
+        } else if (object instanceof Section) {
+            writeSection((Section) object);
+        } else {
+            throw new IllegalArgumentException();
+        }
+    }
+}