From 3319d46b0ff989ed963f11776d0af47a1751a1e0 Mon Sep 17 00:00:00 2001 From: v-almonacid Date: Mon, 3 Aug 2020 15:56:15 +0200 Subject: [PATCH] add ByronAddress:: from_address(), is_valid() --- .../HaskellShelleyModule.java | 15 +++++++++ .../io/emurgo/rnhaskellshelley/Native.java | 2 ++ example/App.js | 29 ++++++++++------ index.d.ts | 12 +++++++ index.js | 18 ++++++++++ ios/HaskellShelley.m | 22 +++++++++++++ rust/src/android/byron_address.rs | 33 +++++++++++++++++-- rust/src/ios/byron_address.rs | 25 +++++++++++++- 8 files changed, 143 insertions(+), 13 deletions(-) diff --git a/android/src/main/java/io/emurgo/rnhaskellshelley/HaskellShelleyModule.java b/android/src/main/java/io/emurgo/rnhaskellshelley/HaskellShelleyModule.java index afdbe89..7538da0 100644 --- a/android/src/main/java/io/emurgo/rnhaskellshelley/HaskellShelleyModule.java +++ b/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 diff --git a/android/src/main/java/io/emurgo/rnhaskellshelley/Native.java b/android/src/main/java/io/emurgo/rnhaskellshelley/Native.java index cfb4c77..cd53724 100644 --- a/android/src/main/java/io/emurgo/rnhaskellshelley/Native.java +++ b/android/src/main/java/io/emurgo/rnhaskellshelley/Native.java @@ -38,6 +38,8 @@ private Native() { } // ByronAddress public final native Result byronAddressToBase58(RPtr byronAddress); public final native Result byronAddressFromBase58(String str); + public final native Result byronAddressIsValid(String str); + public final native Result byronAddressFromAddress(RPtr address); // Address public final native Result addressToBytes(RPtr address); diff --git a/example/App.js b/example/App.js index 795a339..dc3c037 100644 --- a/example/App.js +++ b/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) diff --git a/index.d.ts b/index.d.ts index a02dd0b..198843e 100644 --- a/index.d.ts +++ b/index.d.ts @@ -139,6 +139,18 @@ export class ByronAddress extends Ptr { * @returns {Promise} */ static from_base58(string: string): Promise + + /** + * @param {string} string + * @returns {Promise} + */ + static async is_valid(string): Promise + + /** + * @param {Address} addr + * @returns {Promise} + */ + static from_address(addr): Promise } export class Address extends Ptr { diff --git a/index.js b/index.js index 45a37bc..ff84427 100644 --- a/index.js +++ b/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} + */ + static async is_valid(string) { + return HaskellShelley.byronAddressIsValid(string); + } + + /** + * @param {Address} addr + * @returns {Promise} + */ + 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 { diff --git a/ios/HaskellShelley.m b/ios/HaskellShelley.m index f49fa3e..08c5c7b 100644 --- a/ios/HaskellShelley.m +++ b/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) diff --git a/rust/src/android/byron_address.rs b/rust/src/android/byron_address.rs index 28f28d2..99afb73 100644 --- a/rust/src/android/byron_address.rs +++ b/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::
() + .map(|address| ByronAddress::from_address(address)) + .and_then(|byron_address| byron_address.rptr().jptr(&env)) + }) + .jresult(&env) +} diff --git a/rust/src/ios/byron_address.rs b/rust/src/ios/byron_address.rs index cb7390c..a12c9ce 100644 --- a/rust/src/ios/byron_address.rs +++ b/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::
() + .map(|addr| ByronAddress::from_address(addr)) + }) + .map(|byron_address| byron_address.rptr()) + .response(result, error) +}