Add Ripple Address (trustwallet#18)

Author: vikmeup

JNI/cpp/RippleAddress.c

@@ -0,0 +1,87 @@
+// Copyright © 2017-2019 Trust.
+//
+// This file is part of Trust. The full Trust copyright notice, including
+// terms governing use, modification, and redistribution, is contained in the
+// file LICENSE at the root of the source code distribution tree.
+//
+// This is a GENERATED FILE, changes made here WILL BE LOST.
+//
+
+#include <jni.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <TrustWalletCore/TWPublicKey.h>
+#include <TrustWalletCore/TWRippleAddress.h>
+
+#include "TWJNI.h"
+#include "RippleAddress.h"
+
+jlong JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_nativeCreateWithString(JNIEnv *env, jclass thisClass, jstring string) {
+    TWString *stringString = TWStringCreateWithJString(env, string);
+    struct TWRippleAddress *instance = TWRippleAddressCreateWithString(stringString);
+    TWStringDelete(stringString);
+    return (jlong) instance;
+}
+
+jlong JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_nativeCreateWithData(JNIEnv *env, jclass thisClass, jbyteArray data) {
+    TWData *dataData = TWDataCreateWithJByteArray(env, data);
+    struct TWRippleAddress *instance = TWRippleAddressCreateWithData(dataData);
+    TWDataDelete(dataData);
+    return (jlong) instance;
+}
+
+jlong JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_nativeCreateWithPublicKey(JNIEnv *env, jclass thisClass, jobject publicKey) {
+    jclass publicKeyClass = (*env)->GetObjectClass(env, publicKey);
+    jfieldID publicKeyBytesFieldID = (*env)->GetFieldID(env, publicKeyClass, "bytes", "[B");
+    jbyteArray publicKeyBytesArray = (*env)->GetObjectField(env, publicKey, publicKeyBytesFieldID);
+    jbyte* publicKeyBytesBuffer = (*env)->GetByteArrayElements(env, publicKeyBytesArray, NULL);
+    struct TWPublicKey *publicKeyInstance = (struct TWPublicKey *) publicKeyBytesBuffer;
+    struct TWRippleAddress *instance = TWRippleAddressCreateWithPublicKey(*publicKeyInstance);
+    (*env)->ReleaseByteArrayElements(env, publicKeyBytesArray, publicKeyBytesBuffer, JNI_ABORT);
+    (*env)->DeleteLocalRef(env, publicKeyBytesArray);
+    (*env)->DeleteLocalRef(env, publicKeyClass);
+    return (jlong) instance;
+}
+
+void JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_nativeDelete(JNIEnv *env, jclass thisClass, jlong handle) {
+    TWRippleAddressDelete((struct TWRippleAddress *) handle);
+}
+
+jboolean JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_equals(JNIEnv *env, jclass thisClass, jobject lhs, jobject rhs) {
+    jclass lhsClass = (*env)->GetObjectClass(env, lhs);
+    jfieldID lhsHandleFieldID = (*env)->GetFieldID(env, lhsClass, "nativeHandle", "J");
+    struct TWRippleAddress *lhsInstance = (struct TWRippleAddress *) (*env)->GetLongField(env, lhs, lhsHandleFieldID);
+    jclass rhsClass = (*env)->GetObjectClass(env, rhs);
+    jfieldID rhsHandleFieldID = (*env)->GetFieldID(env, rhsClass, "nativeHandle", "J");
+    struct TWRippleAddress *rhsInstance = (struct TWRippleAddress *) (*env)->GetLongField(env, rhs, rhsHandleFieldID);
+    jboolean resultValue = (jboolean) TWRippleAddressEqual(lhsInstance, rhsInstance);
+
+    (*env)->DeleteLocalRef(env, lhsClass);
+    (*env)->DeleteLocalRef(env, rhsClass);
+
+    return resultValue;
+}
+
+jboolean JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_isValidString(JNIEnv *env, jclass thisClass, jstring string) {
+    TWString *stringString = TWStringCreateWithJString(env, string);
+    jboolean resultValue = (jboolean) TWRippleAddressIsValidString(stringString);
+
+    TWStringDelete(stringString);
+
+    return resultValue;
+}
+
+jstring JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_description(JNIEnv *env, jobject thisObject) {
+    jclass thisClass = (*env)->GetObjectClass(env, thisObject);
+    jfieldID handleFieldID = (*env)->GetFieldID(env, thisClass, "nativeHandle", "J");
+    struct TWRippleAddress *instance = (struct TWRippleAddress *) (*env)->GetLongField(env, thisObject, handleFieldID);
+
+    jstring result = TWStringJString(TWRippleAddressDescription(instance), env);
+
+
+    (*env)->DeleteLocalRef(env, thisClass);
+
+    return result;
+}
+

JNI/cpp/RippleAddress.h

@@ -0,0 +1,42 @@
+// Copyright © 2017-2019 Trust.
+//
+// This file is part of Trust. The full Trust copyright notice, including
+// terms governing use, modification, and redistribution, is contained in the
+// file LICENSE at the root of the source code distribution tree.
+//
+// This is a GENERATED FILE, changes made here WILL BE LOST.
+//
+
+#ifndef JNI_TW_RIPPLEADDRESS_H
+#define JNI_TW_RIPPLEADDRESS_H
+
+#include <jni.h>
+#include <TrustWalletCore/TWBase.h>
+
+TW_EXTERN_C_BEGIN
+
+JNIEXPORT
+jlong JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_nativeCreateWithString(JNIEnv *env, jclass thisClass, jstring string);
+
+JNIEXPORT
+jlong JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_nativeCreateWithData(JNIEnv *env, jclass thisClass, jbyteArray data);
+
+JNIEXPORT
+jlong JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_nativeCreateWithPublicKey(JNIEnv *env, jclass thisClass, jobject publicKey);
+
+JNIEXPORT
+void JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_nativeDelete(JNIEnv *env, jclass thisClass, jlong handle);
+
+JNIEXPORT
+jboolean JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_equals(JNIEnv *env, jclass thisClass, jobject lhs, jobject rhs);
+
+JNIEXPORT
+jboolean JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_isValidString(JNIEnv *env, jclass thisClass, jstring string);
+
+JNIEXPORT
+jstring JNICALL Java_com_wallet_crypto_trustapp_jni_RippleAddress_description(JNIEnv *env, jobject thisObject);
+
+
+TW_EXTERN_C_END
+
+#endif // JNI_TW_RIPPLEADDRESS_H

JNI/java/com/wallet/crypto/trustapp/jni/CoinType.java

@@ -30,7 +30,8 @@ public enum CoinType {
     VECHAIN (818),
     WANCHAIN (5718350),
     ZCOIN (136),
-    ZCASH (133);
+    ZCASH (133),
+    RIPPLE (144);
 
     private final int value;
     CoinType(int value) {

JNI/java/com/wallet/crypto/trustapp/jni/RippleAddress.java

@@ -0,0 +1,88 @@
+// Copyright © 2017-2019 Trust.
+//
+// This file is part of Trust. The full Trust copyright notice, including
+// terms governing use, modification, and redistribution, is contained in the
+// file LICENSE at the root of the source code distribution tree.
+//
+// This is a GENERATED FILE, changes made here WILL BE LOST.
+//
+
+package com.wallet.crypto.trustapp.jni;
+
+import java.security.InvalidParameterException;
+import java.util.HashSet;
+
+public class RippleAddress {
+    private long nativeHandle;
+
+    private RippleAddress() {
+        nativeHandle = 0;
+    }
+
+    static RippleAddress createFromNative(long nativeHandle) {
+        RippleAddress instance = new RippleAddress();
+        instance.nativeHandle = nativeHandle;
+        RippleAddressPhantomReference.register(instance, nativeHandle);
+        return instance;
+    }
+
+    static native long nativeCreateWithString(String string);
+    static native long nativeCreateWithData(byte[] data);
+    static native long nativeCreateWithPublicKey(PublicKey publicKey);
+    static native void nativeDelete(long handle);
+
+    public static native boolean equals(RippleAddress lhs, RippleAddress rhs);
+    public static native boolean isValidString(String string);
+    public native String description();
+
+    public RippleAddress(String string) {
+        nativeHandle = nativeCreateWithString(string);
+        if (nativeHandle == 0) {
+            throw new InvalidParameterException();
+        }
+
+        RippleAddressPhantomReference.register(this, nativeHandle);
+    }
+
+    public RippleAddress(byte[] data) {
+        nativeHandle = nativeCreateWithData(data);
+        if (nativeHandle == 0) {
+            throw new InvalidParameterException();
+        }
+
+        RippleAddressPhantomReference.register(this, nativeHandle);
+    }
+
+    public RippleAddress(PublicKey publicKey) {
+        nativeHandle = nativeCreateWithPublicKey(publicKey);
+        if (nativeHandle == 0) {
+            throw new InvalidParameterException();
+        }
+
+        RippleAddressPhantomReference.register(this, nativeHandle);
+    }
+
+}
+
+class RippleAddressPhantomReference extends java.lang.ref.PhantomReference<RippleAddress> {
+    private static java.util.Set<RippleAddressPhantomReference> references = new HashSet<RippleAddressPhantomReference>();
+    private static java.lang.ref.ReferenceQueue<RippleAddress> queue = new java.lang.ref.ReferenceQueue<RippleAddress>();
+    private long nativeHandle;
+
+    private RippleAddressPhantomReference(RippleAddress referent, long nativeHandle) {
+        super(referent, queue);
+        this.nativeHandle = nativeHandle;
+    }
+
+    static void register(RippleAddress referent, long nativeHandle) {
+        references.add(new RippleAddressPhantomReference(referent, nativeHandle));
+    }
+
+    public static void doDeletes() {
+        RippleAddressPhantomReference ref = (RippleAddressPhantomReference) queue.poll();
+        for (; ref != null; ref = (RippleAddressPhantomReference) queue.poll()) {
+            RippleAddress.nativeDelete(ref.nativeHandle);
+            references.remove(ref);
+        }
+    }
+}

include/TrustWalletCore/TWCoinType.h

@@ -34,6 +34,7 @@ enum TWCoinType {
     TWCoinTypeWanChain = 5718350,
     TWCoinTypeZcoin = 136,
     TWCoinTypeZcash = 133,
+    TWCoinTypeRipple = 144,
 };
 
 TW_EXTERN_C_END

include/TrustWalletCore/TWRippleAddress.h

@@ -0,0 +1,49 @@
+// Copyright © 2017-2019 Trust.
+//
+// This file is part of Trust. The full Trust copyright notice, including
+// terms governing use, modification, and redistribution, is contained in the
+// file LICENSE at the root of the source code distribution tree.
+
+#pragma once
+
+#include "TWBase.h"
+#include "TWData.h"
+#include "TWHRP.h"
+#include "TWString.h"
+
+TW_EXTERN_C_BEGIN
+
+struct TWPublicKey;
+
+/// Represents a Ripple address.
+TW_EXPORT_CLASS
+struct TWRippleAddress;
+
+/// Compares two addresses for equality.
+TW_EXPORT_STATIC_METHOD
+bool TWRippleAddressEqual(struct TWRippleAddress *_Nonnull lhs, struct TWRippleAddress *_Nonnull rhs);
+
+/// Determines if the string is a valid Ripple address.
+TW_EXPORT_STATIC_METHOD
+bool TWRippleAddressIsValidString(TWString *_Nonnull string);
+
+/// Creates an address from a string representaion.
+TW_EXPORT_STATIC_METHOD
+struct TWRippleAddress *_Nullable TWRippleAddressCreateWithString(TWString *_Nonnull string);
+
+/// Creates an address from a raw data representaion.
+TW_EXPORT_STATIC_METHOD
+struct TWRippleAddress *_Nullable TWRippleAddressCreateWithData(TWData *_Nonnull data);
+
+/// Creates an address from a public key.
+TW_EXPORT_STATIC_METHOD
+struct TWRippleAddress *_Nullable TWRippleAddressCreateWithPublicKey(struct TWPublicKey publicKey);
+
+TW_EXPORT_METHOD
+void TWRippleAddressDelete(struct TWRippleAddress *_Nonnull address);
+
+/// Returns the address string representation.
+TW_EXPORT_PROPERTY
+TWString *_Nonnull TWRippleAddressDescription(struct TWRippleAddress *_Nonnull address);
+
+TW_EXTERN_C_END

src/HDWallet.cpp

@@ -9,6 +9,7 @@
 #include "Bitcoin/Bech32Address.h"
 #include "Bitcoin/CashAddress.h"
 #include "Zcash/TAddress.h"
+#include "Ripple/Address.h"
 
 #include <TrezorCrypto/base58.h>
 #include <TrezorCrypto/bip32.h>
@@ -131,6 +132,10 @@ std::optional<std::string> HDWallet::getAddressFromExtended(const std::string& e
         auto address = Zcash::TAddress(reinterpret_cast<PublicKey&>(publicKey), TWP2PKHPrefixZcashT);
         string = address.string();
     } break;
+    case TWCoinTypeRipple: {
+        auto address = Ripple::Address(reinterpret_cast<PublicKey&>(publicKey));
+        string = address.string();
+    } break;
     default:
         // Unknown coin
         return nullptr;

src/Ripple/Address.cpp

@@ -0,0 +1,58 @@
+// Copyright © 2017-2019 Trust.
+//
+// This file is part of Trust. The full Trust copyright notice, including
+// terms governing use, modification, and redistribution, is contained in the
+// file LICENSE at the root of the source code distribution tree.
+
+#include "Address.h"
+
+#include <TrezorCrypto/base58.h>
+#include <TrezorCrypto/ripple/base58.h>
+#include <TrezorCrypto/ecdsa.h>
+#include "../HexCoding.h"
+
+using namespace TW::Ripple;
+
+bool Address::isValid(const std::string& string) {
+    size_t capacity = 128;
+    uint8_t buffer[capacity];
+
+    int size = xrp_base58_decode_check(string.data(), HASHER_SHA2D, buffer, (int)capacity);
+    if (size != Address::size) {
+        return false;
+    }
+
+    return true;
+}
+
+Address::Address(const std::string& string) {
+    size_t capacity = 128;
+    uint8_t buffer[capacity];
+    int size = xrp_base58_decode_check(string.data(), HASHER_SHA2D, buffer, (int)capacity);
+    assert(size == Address::size);
+    std::vector<uint8_t> vec(&buffer[0], &buffer[128]);
+    auto str = TW::hex(vec);
+    memcpy(bytes, buffer, Address::size);
+}
+
+Address::Address(const std::vector<uint8_t>& data) {
+    assert(isValid(data));
+    std::copy(data.begin(), data.end(), bytes);
+}
+
+Address::Address(const PublicKey& publicKey) {
+    /// see type prefix: https://developers.ripple.com/base58-encodings.html
+    bytes[0] = 0x00;
+    ecdsa_get_pubkeyhash(publicKey.bytes.data(), HASHER_SHA2_RIPEMD, bytes + 1);
+}
+
+std::string Address::string() const {
+    size_t size = 0;
+    base58_encode(nullptr, &size, bytes, Address::size, xrp_b58digits);
+    size += 16;
+
+    std::string str(size, ' ');
+    xrp_base58_encode_check(bytes, Address::size, HASHER_SHA2D, &str[0], size);
+
+    return std::string(str.c_str());
+}