add ByronAddress:: from_address(), is_valid()

android/src/main/java/io/emurgo/rnhaskellshelley/HaskellShelleyModule.java

@@ -148,6 +148,21 @@ public final void byronAddressFromBase58(String string, Promise promise) {
                 .pour(promise);
     }
 
+    @ReactMethod
+    public final void byronAddressIsValid(String string, Promise promise) {
+        Native.I
+                .byronAddressIsValid(string)
+                .pour(promise);
+    }
+
+    @ReactMethod
+    public final void byronAddressFromAddress(String address, Promise promise) {
+        Native.I
+                .byronAddressFromAddress(new RPtr(address))
+                .map(RPtr::toJs)
+                .pour(promise);
+    }
+
     // Address
 
     @ReactMethod

android/src/main/java/io/emurgo/rnhaskellshelley/Native.java

@@ -38,6 +38,8 @@ private Native() { }
     // ByronAddress
     public final native Result<String> byronAddressToBase58(RPtr byronAddress);
     public final native Result<RPtr> byronAddressFromBase58(String str);
+    public final native Result<Boolean> byronAddressIsValid(String str);
+    public final native Result<RPtr> byronAddressFromAddress(RPtr address);
 
     // Address
     public final native Result<byte[]> addressToBytes(RPtr address);

example/App.js

@@ -86,16 +86,6 @@ export default class App extends Component<{}> {
         'bip32PrivateKey.as_bytes() should match original input value',
       )
 
-      // ------------------------------------------------
-      // ----------------- ByronAddress -----------------
-      const addrBase58 =
-        'Ae2tdPwUPEZHu3NZa6kCwet2msq4xrBXKHBDvogFKwMsF18Jca8JHLRBas7'
-      const byronAddress = await ByronAddress.from_base58(addrBase58)
-      assert(
-        (await byronAddress.to_base58()) === addrBase58,
-        'ByronAddress.to_base58 should match original input address',
-      )
-
       // ------------------------------------------------
       // ------------------ Address ---------------------
       const baseAddrHex =
@@ -110,6 +100,25 @@ export default class App extends Component<{}> {
         'Address.to_bytes should match original input address',
       )
 
+      // ------------------------------------------------
+      // ----------------- ByronAddress -----------------
+      const addrBase58 =
+        'Ae2tdPwUPEZHu3NZa6kCwet2msq4xrBXKHBDvogFKwMsF18Jca8JHLRBas7'
+      const byronAddress = await ByronAddress.from_base58(addrBase58)
+      assert(
+        (await byronAddress.to_base58()) === addrBase58,
+        'ByronAddress.to_base58 should match original input address',
+      )
+      const byronAddrFromAddr = await ByronAddress.from_address(address)
+      assert(
+        byronAddrFromAddr === undefined,
+        'ByronAddress.from_address should return undefined on non-byron Address',
+      )
+      assert(
+        !(await ByronAddress.is_valid(baseAddrHex)),
+        'ByronAddress.is_valid should return false on non-byron Address',
+      )
+
       // ------------------------------------------------
       // ---------------- Ed25519KeyHash ----------------
       const ed25519KeyHash = await Ed25519KeyHash.from_bytes(addrBytes)

index.d.ts

@@ -139,6 +139,18 @@ export class ByronAddress extends Ptr {
   * @returns {Promise<ByronAddress>}
   */
   static from_base58(string: string): Promise<ByronAddress>
+
+  /**
+  * @param {string} string
+  * @returns {Promise<boolean>}
+  */
+  static async is_valid(string): Promise<boolean>
+
+  /**
+  * @param {Address} addr
+  * @returns {Promise<ByronAddress | undefined>}
+  */
+  static from_address(addr): Promise<ByronAddress>
 }
 
 export class Address extends Ptr {

index.js

@@ -233,6 +233,24 @@ export class ByronAddress extends Ptr {
     const ret = await HaskellShelley.byronAddressFromBase58(string);
     return Ptr._wrap(ret, ByronAddress);
   }
+
+  /**
+  * @param {string} string
+  * @returns {Promise<boolean>}
+  */
+  static async is_valid(string) {
+    return HaskellShelley.byronAddressIsValid(string);
+  }
+
+  /**
+  * @param {Address} addr
+  * @returns {Promise<ByronAddress | undefined>}
+  */
+  static async from_address(addr) {
+    const addrPtr = Ptr._assertClass(addr, Address);
+    const ret = await HaskellShelley.byronAddressFromAddress(addrPtr);
+    return Ptr._wrap(ret, ByronAddress);
+  }
 }
 
 export class Address extends Ptr {

ios/HaskellShelley.m

@@ -182,6 +182,28 @@ @implementation HaskellShelley
     }] exec:string andResolve:resolve orReject:reject];
 }
 
+RCT_EXPORT_METHOD(byronAddressIsValid:(nonnull NSString *)string  withResolve:(RCTPromiseResolveBlock)resolve andReject:(RCTPromiseRejectBlock)reject)
+{
+    [[CSafeOperation new:^NSNumber*(NSString* string, CharPtr* error) {
+        BOOL result;
+        return byron_address_is_valid([string charPtr], &result, error)
+            ? [NSNumber numberWithBool:result]
+            : nil;
+    }] exec:string andResolve:resolve orReject:reject];
+}
+
+RCT_EXPORT_METHOD(byronAddressFromAddress:(nonnull NSString *)addrPtr withResolve:(RCTPromiseResolveBlock)resolve andReject:(RCTPromiseRejectBlock)reject)
+{
+    [[CSafeOperation new:^NSString*(NSArray* params, CharPtr* error) {
+        RPtr result;
+        RPtr addr = [addrPtr rPtr];
+        return byron_address_from_address(addr, &result, error)
+            ? [NSString stringFromPtr:result]
+            : nil;
+    }] exec:addrPtr andResolve:resolve orReject:reject];
+}
+
+
 // Address
 
 RCT_EXPORT_METHOD(addressToBytes:(nonnull NSString *)addressPtr  withResolve:(RCTPromiseResolveBlock)resolve andReject:(RCTPromiseRejectBlock)reject)

rust/src/android/byron_address.rs

@@ -1,12 +1,13 @@
 use jni::objects::{JObject, JString};
-use jni::sys::{jobject};
+use jni::sys::{jobject, jboolean};
 use jni::JNIEnv;
 use super::ptr_j::*;
 use super::result::ToJniResult;
 use super::string::*;
+use super::primitive::ToPrimitiveObject;
 use crate::panic::{handle_exception_result, ToResult};
 use crate::ptr::RPtrRepresentable;
-use cardano_serialization_lib::address::{ByronAddress};
+use cardano_serialization_lib::address::{Address, ByronAddress};
 
 #[allow(non_snake_case)]
 #[no_mangle]
@@ -33,3 +34,31 @@ pub extern "C" fn Java_io_emurgo_rnhaskellshelley_Native_byronAddressFromBase58(
   })
   .jresult(&env)
 }
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub unsafe extern "C" fn Java_io_emurgo_rnhaskellshelley_Native_byronAddressIsValid(
+  env: JNIEnv, _: JObject, string: JString
+) -> jobject {
+  handle_exception_result(|| {
+    let rstr = string.string(&env)?;
+    let val = ByronAddress::is_valid(&rstr);
+    (val as jboolean).jobject(&env)
+  })
+  .jresult(&env)
+}
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub unsafe extern "C" fn Java_io_emurgo_rnhaskellshelley_Native_byronAddressFromAddress(
+  env: JNIEnv, _: JObject, address: JRPtr
+) -> jobject {
+  handle_exception_result(|| {
+    let address = address.rptr(&env)?;
+    address
+      .typed_ref::<Address>()
+      .map(|address| ByronAddress::from_address(address))
+      .and_then(|byron_address| byron_address.rptr().jptr(&env))
+  })
+  .jresult(&env)
+}

rust/src/ios/byron_address.rs

@@ -2,7 +2,7 @@ use super::result::CResult;
 use super::string::*;
 use crate::panic::*;
 use crate::ptr::{RPtr, RPtrRepresentable};
-use cardano_serialization_lib::address::{ByronAddress};
+use cardano_serialization_lib::address::{Address, ByronAddress};
 
 #[no_mangle]
 pub unsafe extern "C" fn byron_address_to_base58(
@@ -19,3 +19,26 @@ pub unsafe extern "C" fn byron_address_from_base58(
   handle_exception_result(|| ByronAddress::from_base58(chars.into_str()).map(|addr| addr.rptr()).into_result())
     .response(result, error)
 }
+
+#[no_mangle]
+pub unsafe extern "C" fn byron_address_is_valid(
+  chars: CharPtr, result: &mut bool, error: &mut CharPtr
+) -> bool {
+  handle_exception_result(|| {
+    Ok(ByronAddress::is_valid(chars.into_str()))
+  })
+    .response(result, error)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn byron_address_from_address(
+  rptr: RPtr, result: &mut RPtr, error: &mut CharPtr
+) -> bool {
+  handle_exception_result(|| {
+    rptr
+      .typed_ref::<Address>()
+      .map(|addr| ByronAddress::from_address(addr))
+    })
+    .map(|byron_address| byron_address.rptr())
+    .response(result, error)
+}