Release candidate: v0.65

chain/core/src/types/address.rs

@@ -20,6 +20,27 @@ impl Address {
         Address(H256::new(bytes))
     }
 
+    /// Constructs an Address from a hex string at compile time.
+    /// The hex string can optionally start with "0x" or "0X".
+    /// The hex string must represent exactly 32 bytes (64 hex characters).
+    ///
+    /// # Panics
+    ///
+    /// Panics at compile time if:
+    /// - The hex string is not exactly 64 characters (excluding optional "0x" prefix)
+    /// - Any character is not a valid hex digit (0-9, a-f, A-F)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use multiversx_chain_core::types::Address;
+    /// const ADDR: Address = Address::from_hex("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
+    /// const ADDR_WITH_PREFIX: Address = Address::from_hex("0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
+    /// ```
+    pub const fn from_hex(hex_str: &str) -> Self {
+        Address(H256::from_hex(hex_str))
+    }
+
     pub fn generate_mock_address(creator_address: &[u8], creator_nonce: u64) -> Self {
         let mut result = [0x00; 32];
 
@@ -275,4 +296,35 @@ mod address_tests {
     fn test_is_zero() {
         assert!(Address::zero().is_zero());
     }
+
+    #[test]
+    fn test_from_hex() {
+        let hex_str = "e32afedc904fe1939746ad973beb383563cf63642ba669b3040f9b9428a5ed60";
+        let addr = Address::from_hex(hex_str);
+        let expected = [
+            0xe3, 0x2a, 0xfe, 0xdc, 0x90, 0x4f, 0xe1, 0x93, 0x97, 0x46, 0xad, 0x97, 0x3b, 0xeb,
+            0x38, 0x35, 0x63, 0xcf, 0x63, 0x64, 0x2b, 0xa6, 0x69, 0xb3, 0x04, 0x0f, 0x9b, 0x94,
+            0x28, 0xa5, 0xed, 0x60,
+        ];
+        assert_eq!(addr.as_array(), &expected);
+    }
+
+    #[test]
+    fn test_from_hex_with_prefix() {
+        let hex_str = "0xE32AFEDC904FE1939746AD973BEB383563CF63642BA669B3040F9B9428A5ED60";
+        let addr = Address::from_hex(hex_str);
+        let expected = [
+            0xE3, 0x2A, 0xFE, 0xDC, 0x90, 0x4F, 0xE1, 0x93, 0x97, 0x46, 0xAD, 0x97, 0x3B, 0xEB,
+            0x38, 0x35, 0x63, 0xCF, 0x63, 0x64, 0x2B, 0xA6, 0x69, 0xB3, 0x04, 0x0F, 0x9B, 0x94,
+            0x28, 0xA5, 0xED, 0x60,
+        ];
+        assert_eq!(addr.as_array(), &expected);
+    }
+
+    #[test]
+    fn test_from_hex_const() {
+        const ADDR: Address =
+            Address::from_hex("e32afedc904fe1939746ad973beb383563cf63642ba669b3040f9b9428a5ed60");
+        assert!(!ADDR.is_zero());
+    }
 }

chain/core/src/types/h256.rs

@@ -12,6 +12,62 @@ impl H256 {
     pub const fn new(bytes: [u8; 32]) -> Self {
         H256(bytes)
     }
+
+    /// Constructs an H256 from a hex string at compile time.
+    /// The hex string can optionally start with "0x" or "0X".
+    /// The hex string must represent exactly 32 bytes (64 hex characters).
+    ///
+    /// # Panics
+    ///
+    /// Panics at compile time if:
+    /// - The hex string is not exactly 64 characters (excluding optional "0x" prefix)
+    /// - Any character is not a valid hex digit (0-9, a-f, A-F)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use multiversx_chain_core::types::H256;
+    /// const HASH: H256 = H256::from_hex("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
+    /// const HASH_WITH_PREFIX: H256 = H256::from_hex("0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
+    /// ```
+    pub const fn from_hex(hex_str: &str) -> Self {
+        let bytes = hex_str.as_bytes();
+        let mut result = [0u8; 32];
+
+        // Skip "0x" prefix if present
+        let start =
+            if bytes.len() >= 2 && bytes[0] == b'0' && (bytes[1] == b'x' || bytes[1] == b'X') {
+                2
+            } else {
+                0
+            };
+
+        let hex_len = bytes.len() - start;
+
+        // Hex string must be exactly 64 characters (32 bytes * 2)
+        if hex_len != 64 {
+            panic!("Hex string must be exactly 64 characters (excluding 0x prefix)");
+        }
+
+        let mut i = 0;
+        while i < 32 {
+            let high = Self::hex_char_to_nibble(bytes[start + i * 2]);
+            let low = Self::hex_char_to_nibble(bytes[start + i * 2 + 1]);
+            result[i] = (high << 4) | low;
+            i += 1;
+        }
+
+        H256::new(result)
+    }
+
+    const fn hex_char_to_nibble(c: u8) -> u8 {
+        match c {
+            b'0'..=b'9' => c - b'0',
+            b'a'..=b'f' => c - b'a' + 10,
+            b'A'..=b'F' => c - b'A' + 10,
+            _ => panic!("Invalid hex character"),
+        }
+    }
 }
 
 impl From<[u8; 32]> for H256 {
@@ -225,4 +281,35 @@ mod h256_tests {
     fn test_is_zero() {
         assert!(H256::zero().is_zero());
     }
+
+    #[test]
+    fn test_from_hex() {
+        let hex_str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+        let h = H256::from_hex(hex_str);
+        let expected = [
+            0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab,
+            0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67,
+            0x89, 0xab, 0xcd, 0xef,
+        ];
+        assert_eq!(h.0, expected);
+    }
+
+    #[test]
+    fn test_from_hex_with_prefix() {
+        let hex_str = "0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";
+        let h = H256::from_hex(hex_str);
+        let expected = [
+            0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB,
+            0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67,
+            0x89, 0xAB, 0xCD, 0xEF,
+        ];
+        assert_eq!(h.0, expected);
+    }
+
+    #[test]
+    fn test_from_hex_const() {
+        const H: H256 =
+            H256::from_hex("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
+        assert!(!H.is_zero());
+    }
 }

chain/vm/Cargo.toml

@@ -30,7 +30,6 @@ hex = "0.4"
 sha2 = "0.10.6"
 sha3 = "0.10.6"
 itertools = "0.14.0"
-hex-literal = "1.0"
 bitflags = "2.9"
 colored = "3.0"
 rand = { version = "0.9", optional = true }

chain/vm/src/blockchain/state/account_data.rs

@@ -4,28 +4,28 @@ use num_traits::Zero;
 use super::AccountEsdt;
 use crate::{
     display_util::key_hex,
-    types::{VMAddress, VMCodeMetadata},
+    types::{Address, VMCodeMetadata},
 };
 use std::{collections::HashMap, fmt, fmt::Write};
 
 pub type AccountStorage = HashMap<Vec<u8>, Vec<u8>>;
 
 #[derive(Clone, Debug)]
 pub struct AccountData {
-    pub address: VMAddress,
+    pub address: Address,
     pub nonce: u64,
     pub egld_balance: BigUint,
     pub esdt: AccountEsdt,
     pub storage: AccountStorage,
     pub username: Vec<u8>,
     pub contract_path: Option<Vec<u8>>,
     pub code_metadata: VMCodeMetadata,
-    pub contract_owner: Option<VMAddress>,
+    pub contract_owner: Option<Address>,
     pub developer_rewards: BigUint,
 }
 
 impl AccountData {
-    pub fn new_empty(address: VMAddress) -> Self {
+    pub fn new_empty(address: Address) -> Self {
         AccountData {
             address,
             nonce: 0,

chain/vm/src/blockchain/state/blockchain_state.rs

@@ -10,15 +10,15 @@ use std::{
 
 use crate::{
     blockchain::reserved::STORAGE_REWARD_KEY, host::context::BlockchainUpdate,
-    system_sc::ESDT_SYSTEM_SC_ADDRESS_ARRAY, types::VMAddress,
+    system_sc::ESDT_SYSTEM_SC_ADDRESS, types::Address,
 };
 
 use super::{AccountData, BlockConfig};
 
 #[derive(Clone)]
 pub struct BlockchainState {
-    pub accounts: HashMap<VMAddress, AccountData>,
-    pub new_addresses: HashMap<(VMAddress, u64), VMAddress>,
+    pub accounts: HashMap<Address, AccountData>,
+    pub new_addresses: HashMap<(Address, u64), Address>,
     pub block_config: BlockConfig,
     pub new_token_identifiers: Vec<String>,
 }
@@ -33,7 +33,7 @@ impl Default for BlockchainState {
         };
 
         // pre-populating system SC(s)
-        state.add_empty_account(ESDT_SYSTEM_SC_ADDRESS_ARRAY.into());
+        state.add_empty_account(ESDT_SYSTEM_SC_ADDRESS);
 
         state
     }
@@ -44,19 +44,19 @@ impl BlockchainState {
         updates.apply(self);
     }
 
-    pub fn account_exists(&self, address: &VMAddress) -> bool {
+    pub fn account_exists(&self, address: &Address) -> bool {
         self.accounts.contains_key(address)
     }
 
-    pub fn increase_account_nonce(&mut self, address: &VMAddress) {
+    pub fn increase_account_nonce(&mut self, address: &Address) {
         let account = self
             .accounts
             .get_mut(address)
             .unwrap_or_else(|| panic!("Account not found: {address}"));
         account.nonce += 1;
     }
 
-    pub fn subtract_tx_gas(&mut self, address: &VMAddress, gas_limit: u64, gas_price: u64) {
+    pub fn subtract_tx_gas(&mut self, address: &Address, gas_limit: u64, gas_price: u64) {
         let account = self
             .accounts
             .get_mut(address)
@@ -69,7 +69,7 @@ impl BlockchainState {
         account.egld_balance -= &gas_cost;
     }
 
-    pub fn increase_validator_reward(&mut self, address: &VMAddress, amount: &BigUint) {
+    pub fn increase_validator_reward(&mut self, address: &Address, amount: &BigUint) {
         let account = self
             .accounts
             .get_mut(address)
@@ -99,7 +99,7 @@ impl BlockchainState {
         self.new_token_identifiers = token_identifiers;
     }
 
-    fn add_empty_account(&mut self, address: VMAddress) {
+    fn add_empty_account(&mut self, address: Address) {
         self.accounts.insert(
             address.clone(),
             AccountData {

chain/vm/src/blockchain/state/blockchain_state_account_util.rs

@@ -1,6 +1,6 @@
 use std::{collections::HashMap, fmt::Write};
 
-use crate::{display_util::address_hex, types::VMAddress};
+use crate::{display_util::address_hex, types::Address};
 
 use super::{AccountData, BlockchainState};
 
@@ -15,7 +15,7 @@ impl BlockchainState {
         self.add_account(acct);
     }
 
-    pub fn update_accounts(&mut self, accounts: HashMap<VMAddress, AccountData>) {
+    pub fn update_accounts(&mut self, accounts: HashMap<Address, AccountData>) {
         self.accounts.extend(accounts);
     }
 
@@ -29,19 +29,15 @@ impl BlockchainState {
 
     pub fn put_new_address(
         &mut self,
-        creator_address: VMAddress,
+        creator_address: Address,
         creator_nonce: u64,
-        new_address: VMAddress,
+        new_address: Address,
     ) {
         self.new_addresses
             .insert((creator_address, creator_nonce), new_address);
     }
 
-    pub fn get_new_address(
-        &self,
-        creator_address: VMAddress,
-        creator_nonce: u64,
-    ) -> Option<VMAddress> {
+    pub fn get_new_address(&self, creator_address: Address, creator_nonce: u64) -> Option<Address> {
         self.new_addresses
             .get(&(creator_address, creator_nonce))
             .cloned()

chain/vm/src/blockchain/state/esdt_instance_metadata.rs

@@ -1,10 +1,10 @@
-use crate::types::VMAddress;
+use crate::types::Address;
 
 /// Holds the data for a MultiversX standard digital token transaction
 #[derive(Clone, Default, Debug)]
 pub struct EsdtInstanceMetadata {
     pub name: Vec<u8>,
-    pub creator: Option<VMAddress>,
+    pub creator: Option<Address>,
     pub royalties: u64,
     pub hash: Option<Vec<u8>>,
     pub uri: Vec<Vec<u8>>,

chain/vm/src/builtin_functions/builtin_func_trait.rs

@@ -1,7 +1,7 @@
 use crate::{
     host::context::{BlockchainUpdate, TxCache, TxInput, TxResult, TxTokenTransfer},
     host::runtime::{RuntimeInstanceCallLambda, RuntimeRef},
-    types::VMAddress,
+    types::Address,
 };
 
 pub trait BuiltinFunction {
@@ -33,7 +33,7 @@ pub trait BuiltinFunction {
 /// Contains a builtin function call ESDT transfers (if any) and the real recipient of the transfer
 /// (can be different from the "to" field.)
 pub struct BuiltinFunctionEsdtTransferInfo {
-    pub real_recipient: VMAddress,
+    pub real_recipient: Address,
     pub transfers: Vec<TxTokenTransfer>,
 }
 

chain/vm/src/builtin_functions/general/change_owner_mock.rs

@@ -2,7 +2,7 @@ use crate::{
     chain_core::builtin_func_names::CHANGE_OWNER_BUILTIN_FUNC_NAME,
     host::context::{BlockchainUpdate, TxCache, TxInput, TxResult},
     host::runtime::{RuntimeInstanceCallLambda, RuntimeRef},
-    types::VMAddress,
+    types::Address,
 };
 
 use super::super::builtin_func_trait::BuiltinFunction;
@@ -31,7 +31,7 @@ impl BuiltinFunction for ChangeOwner {
             );
         }
 
-        let new_owner_address = VMAddress::from_slice(&tx_input.args[0]);
+        let new_owner_address = Address::from_slice(&tx_input.args[0]);
         tx_cache.with_account_mut(&tx_input.to, |account| {
             account.contract_owner = Some(new_owner_address);
         });

chain/vm/src/builtin_functions/transfer/esdt_multi_transfer_mock.rs

@@ -8,7 +8,7 @@ use crate::{
 use crate::{
     builtin_functions::BuiltinFunctionEsdtTransferInfo,
     host::context::{BlockchainUpdate, TxCache, TxInput, TxResult},
-    types::VMAddress,
+    types::Address,
 };
 
 use super::{
@@ -92,7 +92,7 @@ fn try_parse_input(tx_input: &TxInput) -> Result<ParsedTransferBuiltinFunCall, &
 
     let mut arg_index = 0;
     let destination_bytes = tx_input.args[arg_index].as_slice();
-    let destination = VMAddress::from_slice(destination_bytes);
+    let destination = Address::from_slice(destination_bytes);
     arg_index += 1;
     let num_payments = top_decode_u64(tx_input.args[arg_index].as_slice()) as usize;
     arg_index += 1;

chain/vm/src/builtin_functions/transfer/esdt_nft_transfer_mock.rs

@@ -3,7 +3,7 @@ use crate::{
     chain_core::builtin_func_names::ESDT_NFT_TRANSFER_FUNC_NAME,
     host::context::{BlockchainUpdate, TxCache, TxInput, TxLog, TxResult},
     host::runtime::{RuntimeInstanceCallLambda, RuntimeRef},
-    types::VMAddress,
+    types::Address,
 };
 
 use super::{
@@ -87,7 +87,7 @@ fn try_parse_input(tx_input: &TxInput) -> Result<ParsedTransferBuiltinFunCall, &
     let token_identifier = tx_input.args[0].clone();
     let nonce_bytes = tx_input.args[1].clone();
     let value_bytes = tx_input.args[2].clone();
-    let destination = VMAddress::from_slice(&tx_input.args[3]);
+    let destination = Address::from_slice(&tx_input.args[3]);
 
     let func_name = tx_input.func_name_from_arg_index(4);
     let args = if tx_input.args.len() > 5 {