move current work to new rust API and add rust wrappers for unit_inte…

…rval

rust/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2018"
 cbindgen = "0.14.1"
 
 [dependencies]
-cddl-lib = { git = "https://github.com/Emurgo/cardano-serialization-lib.git", branch = "tx-sign", default-features = false }
+cddl-lib = { git = "https://github.com/Emurgo/cardano-serialization-lib.git", branch = "wasm-friendly-regen", default-features = false }
 wasm-bindgen = { version = "0.2" }
 
 [target.'cfg(target_os="android")'.dependencies]

rust/src/android/base_address.rs

@@ -2,7 +2,7 @@ use super::primitive::ToPrimitiveObject;
 use super::ptr_j::*;
 use super::result::ToJniResult;
 // use super::string::ToJniString;
-use crate::panic::{handle_exception_result};
+use crate::panic::{handle_exception_result, Zip};
 use crate::ptr::RPtrRepresentable;
 use jni::objects::JObject;
 use jni::sys::{jobject, jint};
@@ -14,10 +14,19 @@ use cddl_lib::address::{BaseAddress, StakeCredential};
 pub unsafe extern "C" fn Java_io_emurgo_rnhaskellshelley_Native_baseAddressNew(
   env: JNIEnv, _: JObject, network: jint, payment: JRPtr, stake: JRPtr
 ) -> jobject {
-  let payment = payment.owned::<StakeCredential>(&env);
-  let stake = stake.owned::<StakeCredential>(&env);
+  // let payment = payment.owned::<StakeCredential>(&env);
+  // let stake = stake.owned::<StakeCredential>(&env);
+  // handle_exception_result(|| {
+  //   BaseAddress::new(network as u8, payment?, stake?).rptr().jptr(&env)
+  // })
   handle_exception_result(|| {
-    BaseAddress::new(network as u8, payment?, stake?).rptr().jptr(&env)
+    let payment = payment.rptr(&env)?;
+    let stake = stake.rptr(&env)?;
+    payment.typed_ref::<StakeCredential>().zip(stake.typed_ref::<StakeCredential>()).and_then(
+      |(payment, stake)| {
+        BaseAddress::new(network as u8, payment, stake).rptr().jptr(&env)
+      }
+    )
   })
   .jresult(&env)
 }

rust/src/android/stake_credential.rs

@@ -16,9 +16,11 @@ pub unsafe extern "C" fn Java_io_emurgo_rnhaskellshelley_Native_stakeCredentialF
   env: JNIEnv, _: JObject, key_hash_ptr: JRPtr
 ) -> jobject {
   handle_exception_result(|| {
-    let key_hash = key_hash_ptr.owned::<AddrKeyHash>(&env)?;
-    let stake_credential = StakeCredential::from_keyhash(key_hash);
-    stake_credential.rptr().jptr(&env)
+    let key_hash = key_hash_ptr.rptr(&env)?;
+    key_hash
+      .typed_ref::<AddrKeyHash>()
+      .map(|key_hash| StakeCredential::from_keyhash(key_hash))
+      .and_then(|stake_credential| stake_credential.rptr().jptr(&env))
   })
   .jresult(&env)
 }

rust/src/android/unit_interval.rs

@@ -0,0 +1,50 @@
+use super::ptr_j::*;
+use super::result::ToJniResult;
+use crate::panic::{handle_exception_result, ToResult};
+use crate::ptr::RPtrRepresentable;
+use jni::objects::{JObject};
+use jni::sys::{jbyteArray, jobject};
+use jni::JNIEnv;
+use cddl_lib::{UnitInterval};
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub unsafe extern "C" fn Java_io_emurgo_rnhaskellshelley_Native_unitIntervalToBytes(
+  env: JNIEnv, _: JObject, unit_interval: JRPtr
+) -> jobject {
+  handle_exception_result(|| {
+    let unit_interval = unit_interval.rptr(&env)?;
+    unit_interval
+      .typed_ref::<UnitInterval>()
+      .map(|unit_interval| unit_interval.to_bytes())
+      .and_then(|bytes| env.byte_array_from_slice(&bytes).into_result())
+      .map(|arr| JObject::from(arr))
+  })
+  .jresult(&env)
+}
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub unsafe extern "C" fn Java_io_emurgo_rnhaskellshelley_Native_unitIntervalFromBytes(
+  env: JNIEnv, _: JObject, bytes: jbyteArray
+) -> jobject {
+  handle_exception_result(|| {
+    env
+      .convert_byte_array(bytes)
+      .into_result()
+      .and_then(|bytes| UnitInterval::from_bytes(bytes).into_result())
+      .and_then(|unit_interval| unit_interval.rptr().jptr(&env))
+  })
+  .jresult(&env)
+}
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub unsafe extern "C" fn Java_io_emurgo_rnhaskellshelley_Native_unitIntervalNew(
+  env: JNIEnv, _: JObject, index_0: jint, index_1: jint
+) -> jobject {
+  handle_exception_result(|| {
+    UnitInterval::new(index_0 as u32, index_1 as u32).rptr().jptr(&env)
+  })
+  .jresult(&env)
+}

rust/src/ios/addr_key_hash.rs

@@ -14,7 +14,7 @@ pub unsafe extern "C" fn addr_key_hash_to_bytes(
   .response(result, error)
 }
 
-// cddl_lib: Address.from_bytes(Vec<u8>) -> Result<Address, JsValue>
+// cddl_lib: from_bytes(bytes: Vec<u8>) -> Result<$name, JsValue>
 // from react-native-chain-libs address.from_bytes(&[u8]) -> Result<Address, JsValue>
 #[no_mangle]
 pub unsafe extern "C" fn addr_key_hash_from_bytes(

rust/src/ios/base_address.rs

@@ -12,11 +12,11 @@ pub unsafe extern "C" fn base_address_new(
 ) -> bool {
   handle_exception_result(|| {
     payment
-      // .typed_ref::<StakeCredential>()
-      .owned::<StakeCredential>()
+      .typed_ref::<StakeCredential>()
+      // .owned::<StakeCredential>()
       .zip(
-        // stake.typed_ref::<StakeCredential>()
-        stake.owned::<StakeCredential>()
+        stake.typed_ref::<StakeCredential>()
+        // stake.owned::<StakeCredential>()
       )
       .map(|(payment, stake)| {
         BaseAddress::new(network, payment, stake)

rust/src/ios/stake_credential.rs

@@ -11,11 +11,10 @@ pub unsafe extern "C" fn stake_credential_from_keyhash(
   keyhash: RPtr, result: &mut RPtr, error: &mut CharPtr
 ) -> bool {
   handle_exception_result(|| {
-    // let keyhash = keyhash.owned::<AddrKeyHash>(&env)?;
-    keyhash.owned::<AddrKeyHash>()
+    keyhash
+      // .owned::<AddrKeyHash>()
+      .typed_ref::<AddrKeyHash>()
       .map(|keyhash| StakeCredential::from_keyhash(keyhash))
-    // let stake_credential = StakeCredential::from_keyhash(keyhash)
-    // .map(|keyhash| StakeCredential::from_keyhash(keyhash))
   })
     .map(|stake_credential| stake_credential.rptr())
     .response(result, error)

rust/src/ios/unit_interval.rs

@@ -0,0 +1,36 @@
+use super::data::DataPtr;
+use super::result::CResult;
+use super::string::{CharPtr};
+use crate::panic::{handle_exception_result, ToResult};
+use crate::ptr::{RPtr, RPtrRepresentable};
+use cddl_lib::{UnitInterval};
+
+#[no_mangle]
+pub unsafe extern "C" fn unit_interval_to_bytes(
+  unit_interval: RPtr, result: &mut DataPtr, error: &mut CharPtr
+) -> bool {
+  handle_exception_result(|| unit_interval.typed_ref::<UnitInterval>().map(|unit_interval| unit_interval.to_bytes()))
+  .map(|bytes| bytes.into())
+  .response(result, error)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn unit_interval_from_bytes(
+  data: *const u8, len: usize, result: &mut RPtr, error: &mut CharPtr
+) -> bool {
+  handle_exception_result(|| {
+    UnitInterval::from_bytes(std::slice::from_raw_parts(data, len).into()).into_result()
+  })
+  .map(|unit_interval| unit_interval.rptr())
+  .response(result, error)
+}
+
+pub unsafe extern "C" fn unit_interval_new(
+  index_0: u32, index_1: u32, result: &mut RPtr, error: &mut CharPtr
+) -> bool {
+  handle_exception_result(|| {
+    UnitInterval::new(index_0, index_1)
+  })
+    .map(|unit_interval| unit_interval.rptr())
+    .response(result, error)
+}