compiler v2 framework 08- Fixed part of integration testsuit

contrib-contracts/modules/EthStateVerifier.move

@@ -4,15 +4,15 @@ module Bytes {
 
     public fun slice(data: &vector<u8>, start: u64, end: u64): vector<u8> {
         let i = start;
-        let result = Vector::empty<u8>();
-        let data_len = Vector::length(data);
+        let result = vector::empty<u8>();
+        let data_len = vector::length(data);
         let actual_end = if (end < data_len) {
             end
         } else {
             data_len
         };
         while (i < actual_end){
-            Vector::push_back(&mut result, *Vector::borrow(data, i));
+            vector::push_back(&mut result, *vector::borrow(data, i));
             i = i + 1;
         };
         result
@@ -28,14 +28,14 @@ module RLP {
     /// Nested arrays are not supported.
     public fun decode_list(data: &vector<u8>): vector<vector<u8>> {
         let (decoded, consumed) = decode(data, 0);
-        assert!(consumed == Vector::length(data), INVALID_RLP_DATA);
+        assert!(consumed == vector::length(data), INVALID_RLP_DATA);
         decoded
     }
 
     fun decode(data: &vector<u8>, offset: u64): (vector<vector<u8>>, u64) {
-        let data_len = Vector::length(data);
+        let data_len = vector::length(data);
         assert!(offset < data_len, DATA_TOO_SHORT);
-        let first_byte = *Vector::borrow(data, offset);
+        let first_byte = *vector::borrow(data, offset);
         if (first_byte >= 248u8) { // 0xf8
             let length_of_length = ((first_byte - 247u8) as u64);
             assert!(offset + length_of_length < data_len, DATA_TOO_SHORT);
@@ -53,24 +53,24 @@ module RLP {
             assert!(offset + length_of_length + length < data_len, DATA_TOO_SHORT);
 
             let bytes = Bytes::slice(data, offset + 1 + length_of_length, offset + 1 + length_of_length + length);
-            (Vector::singleton(bytes), 1+length_of_length+length)
+            (vector::singleton(bytes), 1+length_of_length+length)
         } else if (first_byte >= 128u8) { // 0x80
             let length = ((first_byte - 128u8) as u64);
             assert!(offset + length < data_len, DATA_TOO_SHORT);
             let bytes = Bytes::slice(data, offset + 1, offset + 1 + length);
-            (Vector::singleton(bytes), 1+length)
+            (vector::singleton(bytes), 1+length)
         } else {
             let bytes = Bytes::slice(data, offset, offset + 1);
-            (Vector::singleton(bytes), 1)
+            (vector::singleton(bytes), 1)
         }
     }
 
     fun decode_children(data: &vector<u8>, offset: u64, child_offset: u64, length: u64): (vector<vector<u8>>, u64) {
-        let result = Vector::empty();
+        let result = vector::empty();
 
         while (child_offset < offset + 1 + length) {
             let (decoded, consumed) = decode(data, child_offset);
-            Vector::append(&mut result, decoded);
+            vector::append(&mut result, decoded);
             child_offset = child_offset + consumed;
             assert!(child_offset <= offset + 1 + length, DATA_TOO_SHORT);
         };
@@ -82,7 +82,7 @@ module RLP {
         let result = 0;
         let i = 0u8;
         while(i < length) {
-            result = result * 256 + (*Vector::borrow(data, offset + (i as u64)) as u64);
+            result = result * 256 + (*vector::borrow(data, offset + (i as u64)) as u64);
             i = i + 1;
         };
         result
@@ -103,13 +103,13 @@ module EthStateVerifier {
         (n1, n2)
     }
     public fun to_nibbles(bytes: &vector<u8>): vector<u8> {
-        let result = Vector::empty<u8>();
+        let result = vector::empty<u8>();
         let i = 0;
-        let data_len = Vector::length(bytes);
+        let data_len = vector::length(bytes);
         while (i < data_len) {
-            let (a, b) = to_nibble(*Vector::borrow(bytes, i));
-            Vector::push_back(&mut result, a);
-            Vector::push_back(&mut result, b);
+            let (a, b) = to_nibble(*vector::borrow(bytes, i));
+            vector::push_back(&mut result, a);
+            vector::push_back(&mut result, b);
             i = i + 1;
         };
 
@@ -124,59 +124,59 @@ module EthStateVerifier {
         key_index: u64,
         proof_index: u64,
     ): bool {
-        if (proof_index >= Vector::length(&proof)) {
+        if (proof_index >= vector::length(&proof)) {
             return false
         };
 
-        let node = Vector::borrow(&proof, proof_index);
+        let node = vector::borrow(&proof, proof_index);
         let dec = RLP::decode_list(node);
         // trie root is always a hash
-        if (key_index == 0 || Vector::length(node) >= 32u64) {
+        if (key_index == 0 || vector::length(node) >= 32u64) {
             if (Hash::keccak_256(*node) != expected_root) {
                 return false
             }
         } else {
             // and if rlp < 32 bytes, then it is not hashed
-            let root = Vector::borrow(&dec, 0);
+            let root = vector::borrow(&dec, 0);
             if (root != &expected_root) {
                 return false
             }
         };
-        let rlp_len = Vector::length(&dec);
+        let rlp_len = vector::length(&dec);
         // branch node.
         if (rlp_len == 17) {
-            if (key_index >= Vector::length(&key)) {
+            if (key_index >= vector::length(&key)) {
                 // value stored in the branch
-                let item = Vector::borrow(&dec, 16);
+                let item = vector::borrow(&dec, 16);
                 if (item == &expected_value) {
                     return true
                 }
             } else {
                 // down the rabbit hole.
-                let index = Vector::borrow(&key, key_index);
-                let new_expected_root = Vector::borrow(&dec, (*index as u64));
-                if (Vector::length(new_expected_root) != 0) {
+                let index = vector::borrow(&key, key_index);
+                let new_expected_root = vector::borrow(&dec, (*index as u64));
+                if (vector::length(new_expected_root) != 0) {
                     return verify_inner(*new_expected_root, key, proof, expected_value, key_index + 1, proof_index + 1)
                 }
             };
         } else if (rlp_len == 2) {
-            let node_key = Vector::borrow(&dec, 0);
-            let node_value = Vector::borrow(&dec, 1);
-            let (prefix, nibble) = to_nibble(*Vector::borrow(node_key, 0));
+            let node_key = vector::borrow(&dec, 0);
+            let node_value = vector::borrow(&dec, 1);
+            let (prefix, nibble) = to_nibble(*vector::borrow(node_key, 0));
 
             if (prefix == 0) {
                 // even extension node
-                let shared_nibbles = to_nibbles(&Bytes::slice(node_key, 1, Vector::length(node_key)));
-                let extension_length = Vector::length(&shared_nibbles);
+                let shared_nibbles = to_nibbles(&Bytes::slice(node_key, 1, vector::length(node_key)));
+                let extension_length = vector::length(&shared_nibbles);
                 if (shared_nibbles ==
                     Bytes::slice(&key, key_index, key_index + extension_length)) {
                         return verify_inner(*node_value, key, proof, expected_value, key_index + extension_length, proof_index + 1)
                 }
             } else if (prefix == 1) {
                 // odd extension node
-                let shared_nibbles = to_nibbles(&Bytes::slice(node_key, 1, Vector::length(node_key)));
-                let extension_length = Vector::length(&shared_nibbles);
-                if (nibble == *Vector::borrow(&key, key_index) &&
+                let shared_nibbles = to_nibbles(&Bytes::slice(node_key, 1, vector::length(node_key)));
+                let extension_length = vector::length(&shared_nibbles);
+                if (nibble == *vector::borrow(&key, key_index) &&
                     shared_nibbles ==
                         Bytes::slice(
                             &key,
@@ -187,21 +187,21 @@ module EthStateVerifier {
                 };
             } else if (prefix == 2) {
                 // even leaf node
-                let shared_nibbles = to_nibbles(&Bytes::slice(node_key, 1, Vector::length(node_key)));
-                return shared_nibbles == Bytes::slice(&key, key_index, Vector::length(&key)) && &expected_value == node_value
+                let shared_nibbles = to_nibbles(&Bytes::slice(node_key, 1, vector::length(node_key)));
+                return shared_nibbles == Bytes::slice(&key, key_index, vector::length(&key)) && &expected_value == node_value
             } else if (prefix == 3) {
                 // odd leaf node
-                let shared_nibbles = to_nibbles(&Bytes::slice(node_key, 1, Vector::length(node_key)));
+                let shared_nibbles = to_nibbles(&Bytes::slice(node_key, 1, vector::length(node_key)));
                 return &expected_value == node_value &&
-                    nibble == *Vector::borrow(&key, key_index) &&
+                    nibble == *vector::borrow(&key, key_index) &&
                      shared_nibbles ==
-                        Bytes::slice(&key, key_index + 1, Vector::length(&key))
+                        Bytes::slice(&key, key_index + 1, vector::length(&key))
             } else {
                 // invalid proof
                 abort INVALID_PROOF
             };
         };
-        return Vector::length(&expected_value) == 0
+        return vector::length(&expected_value) == 0
     }
 
     public fun verify(

contrib-contracts/modules/MerkleDistributor.move

@@ -25,9 +25,9 @@ module MerkleProof {
     public fun verify(proof: &vector<vector<u8>>, root: &vector<u8>, leaf: vector<u8>): bool {
         let computed_hash = leaf;
         let i = 0;
-        let proof_length = Vector::length(proof);
+        let proof_length = vector::length(proof);
         while(i < proof_length) {
-            let sibling = Vector::borrow(proof, i);
+            let sibling = vector::borrow(proof, i);
             // computed_hash is left.
             if (Compare::cmp_bytes(&computed_hash,sibling) < 2) {
                 let concated = concat(computed_hash, *sibling);
@@ -45,7 +45,7 @@ module MerkleProof {
 
 
     fun concat(v1: vector<u8>, v2: vector<u8>): vector<u8> {
-        Vector::append(&mut v1, v2);
+        vector::append(&mut v1, v2);
         v1
     }
 }
@@ -77,10 +77,10 @@ module MerkleDistributor {
         if (bitmap_count * 128 < leaves) {
             bitmap_count = bitmap_count + 1;
         };
-        let claimed_bitmap = Vector::empty();
+        let claimed_bitmap = vector::empty();
         let j = 0;
         while (j < bitmap_count) {
-            Vector::push_back(&mut claimed_bitmap, 0u128);
+            vector::push_back(&mut claimed_bitmap, 0u128);
             j = j + 1;
         };
         let distribution = MerkleDistribution{
@@ -129,25 +129,25 @@ module MerkleDistributor {
     fun is_claimed_<T: store>(distribution: &MerkleDistribution<T>, index: u64): bool {
         let claimed_word_index = index / 128;
         let claimed_bit_index = ((index % 128) as u8);
-        let word = Vector::borrow(&distribution.claimed_bitmap, claimed_word_index);
+        let word = vector::borrow(&distribution.claimed_bitmap, claimed_word_index);
         let mask = 1u128 << claimed_bit_index;
         (*word & mask) == mask
     }
 
     fun set_claimed_<T: store>(distribution: &mut MerkleDistribution<T>, index: u64) {
         let claimed_word_index = index / 128;
         let claimed_bit_index = ((index % 128) as u8);
-        let word = Vector::borrow_mut(&mut distribution.claimed_bitmap, claimed_word_index);
+        let word = vector::borrow_mut(&mut distribution.claimed_bitmap, claimed_word_index);
         // word | (1 << bit_index)
         let mask = 1u128 << claimed_bit_index;
         *word = (*word | mask);
     }
 
     fun encode_leaf(index: &u64, account: &address, amount: &u128): vector<u8> {
-        let leaf = Vector::empty();
-        Vector::append(&mut leaf, BCS::to_bytes(index));
-        Vector::append(&mut leaf, BCS::to_bytes(account));
-        Vector::append(&mut leaf, BCS::to_bytes(amount));
+        let leaf = vector::empty();
+        vector::append(&mut leaf, BCS::to_bytes(index));
+        vector::append(&mut leaf, BCS::to_bytes(account));
+        vector::append(&mut leaf, BCS::to_bytes(amount));
         leaf
     }
 }

contrib-contracts/modules/StarcoinVerifier.move

@@ -42,9 +42,9 @@ address StarcoinAssociation {
             let leaf_node = Node { hash1: copy address_hash, hash2: account_state_root_hash};
             let current_hash = StructuredHash::hash(SPARSE_MERKLE_LEAF_NODE, &leaf_node);
             let i = 0;
-            let proof_length = Vector::length(&proofs);
+            let proof_length = vector::length(&proofs);
             while (i < proof_length) {
-                let sibling = *Vector::borrow(&proofs, i);
+                let sibling = *vector::borrow(&proofs, i);
                 let bit = Bit::get_bit(&address_hash, proof_length - i - 1);
                 let internal_node = if (bit) {
                     Node {hash1: sibling, hash2: current_hash}
@@ -71,7 +71,7 @@ address StarcoinAssociation {
 
         fun concat(v1: &vector<u8>, v2: vector<u8>): vector<u8> {
             let data = *v1;
-            Vector::append(&mut data, v2);
+            vector::append(&mut data, v2);
             data
         }
 
@@ -81,7 +81,7 @@ address StarcoinAssociation {
         public fun get_bit(data: &vector<u8>, index: u64): bool {
             let pos = index / 8;
             let bit = (7 - index % 8);
-            (*Vector::borrow(data, pos) >> (bit as u8)) & 1u8 != 0
+            (*vector::borrow(data, pos) >> (bit as u8)) & 1u8 != 0
         }
     }
 }

etc/starcoin_types.yml

@@ -114,7 +114,11 @@ EventKey:
     - account_address:
         TYPENAME: AccountAddress
 HashValue:
-  NEWTYPESTRUCT: BYTES
+  STRUCT:
+    - hash:
+        TUPLEARRAY:
+          CONTENT: U8
+          SIZE: 32
 Identifier:
   NEWTYPESTRUCT: STR
 Module:

executor/tests/block_test.rs

@@ -0,0 +1,55 @@
+use log::info;
+use starcoin_types::account_address::AccountAddress;
+use starcoin_vm_types::account_config::genesis_address;
+use starcoin_vm_types::{
+    event::{EventHandle, EventKey},
+    on_chain_resource::BlockMetadata,
+    state_view::StateReaderExt,
+};
+use test_helper::executor::prepare_genesis;
+
+#[stest::test]
+fn test_block_metadata_bcs_deserialize() -> anyhow::Result<()> {
+    let (chain_state, _net) = prepare_genesis();
+
+    let block_metadata = BlockMetadata {
+        number: 0,
+        parent_hash: Default::default(),
+        author: AccountAddress::ONE,
+        uncles: 0,
+        parents_hash: vec![],
+        new_block_events: EventHandle::new(EventKey::new(1, AccountAddress::ONE), 1),
+    };
+    let bcs_block_metadata = bcs_ext::to_bytes(&block_metadata)?;
+    info!(
+        "block_metadata: {:?}, length: {}",
+        bcs_block_metadata,
+        bcs_block_metadata.len()
+    );
+
+    let onchain_data = chain_state.get_resource_type_bytes::<BlockMetadata>(genesis_address())?;
+    info!(
+        "onchain block_metadata: {:?}, data len: {}",
+        onchain_data.to_vec(),
+        onchain_data.len()
+    );
+    let on_chain_block_data =
+        bcs_ext::from_bytes::<BlockMetadata>(onchain_data.to_vec().as_slice())?;
+    assert_eq!(on_chain_block_data.number, 0);
+
+    assert_eq!(
+        chain_state
+            .get_resource_type::<BlockMetadata>(genesis_address())?
+            .number,
+        0
+    );
+
+    // let output = bcs_ext::from_bytes::<BlockMetadata>(bcs.as_slice())?;
+    // assert_eq!(output.number, block_metadata.number);
+    //
+    // let data = chain_state.get_resource_type::<BlockMetadata>(genesis_address())?;
+    // assert_ne!(data.number, 0);
+    // assert!(!block_metadata.number > 0);
+
+    Ok(())
+}