1  // Copyright (c) 2019-2025 Alpha-Delta Network Inc.
 2  // This file is part of the alphavm library.
 3  
 4  // Licensed under the Apache License, Version 2.0 (the "License");
 5  // you may not use this file except in compliance with the License.
 6  // You may obtain a copy of the License at:
 7  
 8  // http://www.apache.org/licenses/LICENSE-2.0
 9  
10  // Unless required by applicable law or agreed to in writing, software
11  // distributed under the License is distributed on an "AS IS" BASIS,
12  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  // See the License for the specific language governing permissions and
14  // limitations under the License.
15  
16  use super::*;
17  
18  impl<N: Network> ToBits for Metadata<N> {
19      /// Returns the little-endian bits of the metadata.
20      #[rustfmt::skip]
21      fn write_bits_le(&self, vec: &mut Vec<bool>) {
22          0u8.write_bits_le(vec);                               // 1 byte
23          self.network.write_bits_le(vec);                      // 2 bytes
24          self.round.write_bits_le(vec);                        // 8 bytes
25          self.height.write_bits_le(vec);                       // 4 bytes
26          self.cumulative_weight.write_bits_le(vec);            // 16 bytes
27          self.cumulative_proof_target.write_bits_le(vec);      // 16 bytes
28          self.coinbase_target.write_bits_le(vec);              // 8 bytes
29          self.proof_target.write_bits_le(vec);                 // 8 bytes
30          self.last_coinbase_target.write_bits_le(vec);         // 8 bytes
31          self.last_coinbase_timestamp.write_bits_le(vec);      // 8 bytes
32          self.timestamp.write_bits_le(vec);                    // 8 bytes
33      }
34  
35      /// Returns the big-endian bits of the metadata.
36      #[rustfmt::skip]
37      fn write_bits_be(&self, vec: &mut Vec<bool>) {
38          0u8.write_bits_be(vec);                               // 1 byte
39          self.network.write_bits_be(vec);                      // 2 bytes
40          self.round.write_bits_be(vec);                        // 8 bytes
41          self.height.write_bits_be(vec);                       // 4 bytes
42          self.cumulative_weight.write_bits_be(vec);            // 16 bytes
43          self.cumulative_proof_target.write_bits_be(vec);      // 16 bytes
44          self.coinbase_target.write_bits_be(vec);              // 8 bytes
45          self.proof_target.write_bits_be(vec);                 // 8 bytes
46          self.last_coinbase_target.write_bits_be(vec);         // 8 bytes
47          self.last_coinbase_timestamp.write_bits_be(vec);      // 8 bytes
48          self.timestamp.write_bits_be(vec);                    // 8 bytes
49      }
50  }
51  
52  #[cfg(test)]
53  mod tests {
54      use super::*;
55  
56      #[test]
57      fn test_bits_le() {
58          let rng = &mut TestRng::default();
59  
60          for expected in [crate::header::metadata::test_helpers::sample_block_metadata(rng)].into_iter() {
61              // Check the length matches.
62              let expected_bytes = expected.to_bytes_le().unwrap();
63              let expected_bits = expected.to_bits_le();
64              assert_eq!(expected_bytes.to_bits_le().len(), expected_bits.len());
65          }
66      }
67  
68      #[test]
69      fn test_bits_be() {
70          let rng = &mut TestRng::default();
71  
72          for expected in [crate::header::metadata::test_helpers::sample_block_metadata(rng)].into_iter() {
73              // Check the length matches.
74              let expected_bytes = expected.to_bytes_le().unwrap(); // There is no 'to_bytes_be' function.
75              let expected_bits = expected.to_bits_be();
76              assert_eq!(expected_bytes.to_bits_be().len(), expected_bits.len());
77          }
78      }
79  }