Cleanup account resource implementation

libra-dev/include/data.h

@@ -5,6 +5,7 @@
 extern "C" {
 #endif
 
+#include <stddef.h>
 #include <stdint.h>
 #include <stdbool.h>
 
@@ -16,7 +17,7 @@ struct CEventHandle {
 struct CDevAccountResource {
     uint64_t balance;
     uint64_t sequence;
-    uint8_t* authentication_key;
+    uint8_t authentication_key[32];
     bool delegated_key_rotation_capability;
     bool delegated_withdrawal_capability;
     struct CEventHandle sent_events;

libra-dev/src/account_resource.rs

@@ -9,133 +9,74 @@ use libra_types::{
 };
 use std::slice;
 
-#[derive(Debug)]
-pub struct DevAccountResource {
-    balance: u64,
-    sequence_number: u64,
-    authentication_key: ByteArray,
-    delegated_key_rotation_capability: bool,
-    delegated_withdrawal_capability: bool,
-    sent_events: EventHandle,
-    received_events: EventHandle,
-}
-
-impl DevAccountResource {
-    pub fn new(account_state_blob: AccountStateBlob) -> Self {
-        let account_resource = get_account_resource_or_default(&Some(account_state_blob)).unwrap();
-
-        Self {
-            balance: account_resource.balance(),
-            sequence_number: account_resource.sequence_number(),
-            authentication_key: account_resource.authentication_key().clone(),
-            delegated_key_rotation_capability: account_resource.delegated_key_rotation_capability(),
-            delegated_withdrawal_capability: account_resource.delegated_withdrawal_capability(),
-            sent_events: account_resource.sent_events().clone(),
-            received_events: account_resource.received_events().clone(),
-        }
-    }
-
-    /// Return the authentication_key field for the given AccountResource
-    pub fn authentication_key(&self) -> &ByteArray {
-        &self.authentication_key
-    }
-
-    /// Return the balance field for the given AccountResource
-    pub fn balance(&self) -> u64 {
-        self.balance
-    }
-
-    /// Return the sequence_number field for the given AccountResource
-    pub fn sequence_number(&self) -> u64 {
-        self.sequence_number
-    }
-
-    /// Return the delegated_key_rotation_capability field for the given AccountResource
-    pub fn delegated_key_rotation_capability(&self) -> bool {
-        self.delegated_key_rotation_capability
-    }
-
-    /// Return the delegated_withdrawal_capability field for the given AccountResource
-    pub fn delegated_withdrawal_capability(&self) -> bool {
-        self.delegated_withdrawal_capability
-    }
-
-    /// Return the sent_events field for the given AccountResource
-    pub fn sent_events(&self) -> &EventHandle {
-        &self.sent_events
-    }
-
-    /// Return the received_events field for the given AccountResource
-    pub fn received_events(&self) -> &EventHandle {
-        &self.received_events
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn account_resource_free(account_resource: *mut CDevAccountResource) {
-    let _: Box<DevAccountResource> = Box::from_raw(account_resource.cast());
-}
-
 #[no_mangle]
-pub unsafe extern "C" fn account_resource_from_lcs(
+pub extern "C" fn account_resource_from_lcs(
     buf: *const u8,
     len: usize,
 ) -> CDevAccountResource {
-    let buf: &[u8] = slice::from_raw_parts(buf, len);
+    let buf: &[u8] = unsafe { slice::from_raw_parts(buf, len) };
 
-    let account_state_blob: AccountStateBlob = AccountStateBlob::from(buf.to_vec());
-    let account_resource = DevAccountResource::new(account_state_blob);
+    let account_state_blob = AccountStateBlob::from(buf.to_vec());
+    let account_resource =
+        get_account_resource_or_default(&Some(account_state_blob)).expect("fixme!");
 
-    let authentication_key = account_resource.authentication_key.into_inner();
-    let mut key_slice = authentication_key.into_boxed_slice();
-    let authentication_key_ptr = key_slice.as_mut_ptr();
-    std::mem::forget(key_slice);
+    let mut authentication_key = [0u8; 32];
+    authentication_key.copy_from_slice(account_resource.authentication_key().as_bytes());
 
     let mut sent_key_copy = [0u8; EVENT_KEY_LENGTH];
-    sent_key_copy.copy_from_slice(account_resource.sent_events.key().as_bytes());
+    sent_key_copy.copy_from_slice(account_resource.sent_events().key().as_bytes());
 
     let sent_events = CEventHandle {
-        count: account_resource.sent_events.count(),
+        count: account_resource.sent_events().count(),
         key: sent_key_copy,
     };
 
     let mut received_key_copy = [0u8; EVENT_KEY_LENGTH];
-    received_key_copy.copy_from_slice(account_resource.received_events.key().as_bytes());
+    received_key_copy.copy_from_slice(account_resource.received_events().key().as_bytes());
 
     let received_events = CEventHandle {
-        count: account_resource.received_events.count(),
+        count: account_resource.received_events().count(),
         key: received_key_copy,
     };
 
-    return CDevAccountResource {
-        balance: account_resource.balance,
-        sequence: account_resource.sequence_number,
-        authentication_key: authentication_key_ptr,
-        delegated_key_rotation_capability: account_resource.delegated_key_rotation_capability,
-        delegated_withdrawal_capability: account_resource.delegated_withdrawal_capability,
+
+    let result = CDevAccountResource {
+        balance: account_resource.balance(),
+        sequence: account_resource.sequence_number(),
+        delegated_key_rotation_capability: account_resource.delegated_key_rotation_capability(),
+        delegated_withdrawal_capability: account_resource.delegated_withdrawal_capability(),
         sent_events,
         received_events,
+        authentication_key,
     };
+
+    return result;
 }
 
 /// Generate an AccountBlob and verify we can parse it
 #[test]
 fn test_get_account_resource() {
-    use std::{collections::BTreeMap, convert::TryInto};
+    use std::collections::BTreeMap;
     use libra_types::account_config::account_resource_path;
     use libra_types::account_config::AccountResource;
+    use libra_crypto::ed25519::compat;
+    use libra_types::account_address::AccountAddress;
+
+
+    let keypair = compat::generate_keypair(None);
 
     // Figure out how to use Libra code to generate AccountStateBlob directly, not involving btreemap directly
     let mut map: BTreeMap<Vec<u8>, Vec<u8>> = BTreeMap::new();
     let ar = AccountResource::new(
         987654321,
         123456789,
-        ByteArray::new(vec![1,2,3,4]),
+        ByteArray::new(AccountAddress::from_public_key(&keypair.1).to_vec()),
         true,
         false,
         EventHandle::default(),
         EventHandle::default(),
     );
+
     // Fill in data
     map.insert(account_resource_path(), lcs::to_bytes(&ar ).expect("Must success"));
 
@@ -147,4 +88,11 @@ fn test_get_account_resource() {
 
     assert_eq!(result.balance, ar.balance());
     assert_eq!(result.sequence, ar.sequence_number());
+    assert_eq!(result.authentication_key, ar.authentication_key().as_bytes() );
+    assert_eq!(result.delegated_key_rotation_capability, ar.delegated_key_rotation_capability());
+    assert_eq!(result.delegated_withdrawal_capability, ar.delegated_withdrawal_capability());
+    assert_eq!(result.sent_events.count, ar.sent_events().count());
+    assert_eq!(result.sent_events.key, ar.sent_events().key().as_bytes());
+    assert_eq!(result.received_events.count, ar.received_events().count());
+    assert_eq!(result.received_events.key, ar.received_events().key().as_bytes());
 }

libra-dev/src/data.rs

@@ -44,7 +44,7 @@ fn bindgen_test_layout_CEventHandle() {
 pub struct CDevAccountResource {
     pub balance: u64,
     pub sequence: u64,
-    pub authentication_key: *mut u8,
+    pub authentication_key: [u8; 32usize],
     pub delegated_key_rotation_capability: bool,
     pub delegated_withdrawal_capability: bool,
     pub sent_events: CEventHandle,
@@ -54,7 +54,7 @@ pub struct CDevAccountResource {
 fn bindgen_test_layout_CDevAccountResource() {
     assert_eq!(
         ::std::mem::size_of::<CDevAccountResource>(),
-        112usize,
+        136usize,
         concat!("Size of: ", stringify!(CDevAccountResource))
     );
     assert_eq!(
@@ -99,7 +99,7 @@ fn bindgen_test_layout_CDevAccountResource() {
             &(*(::std::ptr::null::<CDevAccountResource>())).delegated_key_rotation_capability
                 as *const _ as usize
         },
-        24usize,
+        48usize,
         concat!(
             "Offset of field: ",
             stringify!(CDevAccountResource),
@@ -112,7 +112,7 @@ fn bindgen_test_layout_CDevAccountResource() {
             &(*(::std::ptr::null::<CDevAccountResource>())).delegated_withdrawal_capability
                 as *const _ as usize
         },
-        25usize,
+        49usize,
         concat!(
             "Offset of field: ",
             stringify!(CDevAccountResource),
@@ -122,7 +122,7 @@ fn bindgen_test_layout_CDevAccountResource() {
     );
     assert_eq!(
         unsafe { &(*(::std::ptr::null::<CDevAccountResource>())).sent_events as *const _ as usize },
-        32usize,
+        56usize,
         concat!(
             "Offset of field: ",
             stringify!(CDevAccountResource),
@@ -134,7 +134,7 @@ fn bindgen_test_layout_CDevAccountResource() {
         unsafe {
             &(*(::std::ptr::null::<CDevAccountResource>())).received_events as *const _ as usize
         },
-        72usize,
+        96usize,
         concat!(
             "Offset of field: ",
             stringify!(CDevAccountResource),

libra-dev/src/lib.rs

@@ -1,5 +1,10 @@
 // Copyright (c) The Libra Core Contributors
 // SPDX-License-Identifier: Apache-2.0
 
-pub mod account_resource;
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
 mod data;
+
+pub mod account_resource;
+