TokenId type

framework/base/src/contract_base/wrappers/blockchain_wrapper.rs

@@ -491,7 +491,7 @@ where
             uris_handle.get_raw_handle(),
         );
 
-        let token_type = self.get_esdt_token_type(address, &token_id.data, nonce);
+        let token_type = self.get_esdt_token_type(address, token_id.token_id.as_legacy(), nonce);
 
         if managed_api_impl.mb_len(creator_handle.clone()) == 0 {
             managed_api_impl.mb_overwrite(creator_handle.clone(), &[0u8; 32][..]);

framework/base/src/types/interaction/tx_data/function_call.rs

@@ -203,7 +203,7 @@ where
         for payment in payments {
             // serializing token identifier buffer to get EGLD-00000 instead of EGLD
             result = result
-                .argument(&payment.token_identifier.buffer)
+                .argument(&payment.token_identifier.token_id)
                 .argument(&payment.token_nonce)
                 .argument(&payment.amount);
         }

framework/base/src/types/managed/wrapped/token.rs

@@ -5,6 +5,7 @@ mod esdt_token_data;
 mod esdt_token_identifier;
 mod esdt_token_payment;
 mod multi_egld_or_esdt_token_payment;
+mod token_id;
 
 pub use egld_or_esdt_token_identifier::EgldOrEsdtTokenIdentifier;
 pub use egld_or_esdt_token_payment::{EgldOrEsdtTokenPayment, EgldOrEsdtTokenPaymentRefs};
@@ -13,3 +14,4 @@ pub use esdt_token_data::EsdtTokenData;
 pub use esdt_token_identifier::{EsdtTokenIdentifier, TokenIdentifier};
 pub use esdt_token_payment::{EsdtTokenPayment, EsdtTokenPaymentRefs, MultiEsdtPayment};
 pub use multi_egld_or_esdt_token_payment::MultiEgldOrEsdtPayment;
+pub use token_id::TokenId;

framework/base/src/types/managed/wrapped/token/egld_or_esdt_token_identifier.rs

@@ -3,15 +3,12 @@ use multiversx_chain_core::EGLD_000000_TOKEN_IDENTIFIER;
 
 use crate::{
     abi::{TypeAbi, TypeAbiFrom, TypeName},
-    api::{
-        const_handles, use_raw_handle, ErrorApiImpl, HandleConstraints, ManagedBufferApiImpl,
-        ManagedTypeApi,
-    },
+    api::{const_handles, use_raw_handle, ErrorApiImpl, ManagedBufferApiImpl, ManagedTypeApi},
     codec::*,
     err_msg,
     formatter::{FormatByteReceiver, SCDisplay, SCLowerHex},
     proxy_imports::TestTokenIdentifier,
-    types::{EsdtTokenIdentifier, ManagedBuffer, ManagedRef, ManagedType},
+    types::{EsdtTokenIdentifier, ManagedBuffer, ManagedRef, ManagedType, TokenId},
 };
 
 /// Specialized type for handling either EGLD or ESDT token identifiers.
@@ -32,7 +29,7 @@ use crate::{
 #[repr(transparent)]
 #[derive(Clone)]
 pub struct EgldOrEsdtTokenIdentifier<M: ManagedTypeApi> {
-    pub(crate) buffer: ManagedBuffer<M>,
+    pub(crate) token_id: TokenId<M>,
 }
 
 impl<M: ManagedTypeApi> ManagedType<M> for EgldOrEsdtTokenIdentifier<M> {
@@ -41,16 +38,16 @@ impl<M: ManagedTypeApi> ManagedType<M> for EgldOrEsdtTokenIdentifier<M> {
     #[inline]
     unsafe fn from_handle(handle: M::ManagedBufferHandle) -> Self {
         EgldOrEsdtTokenIdentifier {
-            buffer: ManagedBuffer::from_handle(handle),
+            token_id: TokenId::from_handle(handle),
         }
     }
 
     fn get_handle(&self) -> M::ManagedBufferHandle {
-        self.buffer.get_handle()
+        self.token_id.get_handle()
     }
 
     unsafe fn forget_into_handle(self) -> Self::OwnHandle {
-        self.buffer.forget_into_handle()
+        self.token_id.forget_into_handle()
     }
 
     fn transmute_from_handle_ref(handle_ref: &M::ManagedBufferHandle) -> &Self {
@@ -70,7 +67,7 @@ impl<M: ManagedTypeApi> EgldOrEsdtTokenIdentifier<M> {
     #[inline]
     pub fn egld() -> Self {
         EgldOrEsdtTokenIdentifier {
-            buffer: ManagedBuffer::from(EGLD_000000_TOKEN_IDENTIFIER),
+            token_id: TokenId::from(EGLD_000000_TOKEN_IDENTIFIER),
         }
     }
 
@@ -81,14 +78,16 @@ impl<M: ManagedTypeApi> EgldOrEsdtTokenIdentifier<M> {
         EsdtTokenIdentifier<M>: From<TI>,
     {
         let ti_obj = EsdtTokenIdentifier::from(token_identifier);
-        ti_obj.data
+        ti_obj.token_id.into()
     }
 
     pub fn parse(data: ManagedBuffer<M>) -> Self {
         if data == Self::EGLD_REPRESENTATION {
             Self::egld()
         } else {
-            Self { buffer: data }
+            Self {
+                token_id: data.into(),
+            }
         }
     }
 
@@ -100,7 +99,7 @@ impl<M: ManagedTypeApi> EgldOrEsdtTokenIdentifier<M> {
         );
         M::managed_type_impl().mb_eq(
             use_raw_handle(const_handles::MBUF_EGLD_000000),
-            self.buffer.handle.clone(),
+            self.token_id.buffer.handle.clone(),
         )
     }
 
@@ -131,17 +130,17 @@ impl<M: ManagedTypeApi> EgldOrEsdtTokenIdentifier<M> {
 
     #[inline]
     pub fn into_managed_buffer(self) -> ManagedBuffer<M> {
-        self.buffer
+        self.token_id.buffer
     }
 
     #[inline]
     pub fn as_managed_buffer(&self) -> &ManagedBuffer<M> {
-        &self.buffer
+        &self.token_id.buffer
     }
 
     #[inline]
     pub fn to_boxed_bytes(&self) -> crate::types::heap::BoxedBytes {
-        self.buffer.to_boxed_bytes()
+        self.token_id.to_boxed_bytes()
     }
 
     pub fn map_or_else<Context, D, F, R>(self, context: Context, for_egld: D, for_esdt: F) -> R
@@ -206,14 +205,23 @@ impl<M: ManagedTypeApi> EgldOrEsdtTokenIdentifier<M> {
 impl<M: ManagedTypeApi> From<ManagedBuffer<M>> for EgldOrEsdtTokenIdentifier<M> {
     #[inline]
     fn from(buffer: ManagedBuffer<M>) -> Self {
-        EgldOrEsdtTokenIdentifier { buffer }
+        EgldOrEsdtTokenIdentifier {
+            token_id: buffer.into(),
+        }
+    }
+}
+
+impl<M: ManagedTypeApi> From<TokenId<M>> for EgldOrEsdtTokenIdentifier<M> {
+    #[inline]
+    fn from(token_id: TokenId<M>) -> Self {
+        EgldOrEsdtTokenIdentifier { token_id }
     }
 }
 
 impl<M: ManagedTypeApi> From<&[u8]> for EgldOrEsdtTokenIdentifier<M> {
     fn from(bytes: &[u8]) -> Self {
         EgldOrEsdtTokenIdentifier {
-            buffer: ManagedBuffer::new_from_bytes(bytes),
+            token_id: TokenId::from(bytes),
         }
     }
 }
@@ -233,7 +241,7 @@ impl<M: ManagedTypeApi> From<&String> for EgldOrEsdtTokenIdentifier<M> {
 impl<M: ManagedTypeApi> PartialEq for EgldOrEsdtTokenIdentifier<M> {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
-        self.buffer == other.buffer
+        self.token_id == other.token_id
     }
 }
 
@@ -260,7 +268,7 @@ impl<M: ManagedTypeApi> NestedEncode for EgldOrEsdtTokenIdentifier<M> {
         if self.is_egld() {
             (&Self::EGLD_REPRESENTATION[..]).dep_encode_or_handle_err(dest, h)
         } else {
-            self.buffer.dep_encode_or_handle_err(dest, h)
+            self.token_id.dep_encode_or_handle_err(dest, h)
         }
     }
 }
@@ -275,7 +283,7 @@ impl<M: ManagedTypeApi> TopEncode for EgldOrEsdtTokenIdentifier<M> {
         if self.is_egld() {
             (&Self::EGLD_REPRESENTATION[..]).top_encode_or_handle_err(output, h)
         } else {
-            self.buffer.top_encode_or_handle_err(output, h)
+            self.token_id.top_encode_or_handle_err(output, h)
         }
     }
 }
@@ -337,9 +345,7 @@ impl<M: ManagedTypeApi> SCDisplay for EgldOrEsdtTokenIdentifier<M> {
         if self.is_egld() {
             f.append_bytes(Self::EGLD_REPRESENTATION);
         } else {
-            let cast_handle = self.buffer.get_handle().cast_or_signal_error::<M, _>();
-            let wrap_cast = unsafe { ManagedRef::wrap_handle(cast_handle) };
-            f.append_managed_buffer(&wrap_cast);
+            SCDisplay::fmt(&self.token_id, f)
         }
     }
 }
@@ -351,9 +357,7 @@ impl<M: ManagedTypeApi> SCLowerHex for EgldOrEsdtTokenIdentifier<M> {
         if self.is_egld() {
             f.append_bytes(EGLD_REPRESENTATION_HEX);
         } else {
-            let cast_handle = self.buffer.get_handle().cast_or_signal_error::<M, _>();
-            let wrap_cast = unsafe { ManagedRef::wrap_handle(cast_handle) };
-            f.append_managed_buffer_lower_hex(&wrap_cast);
+            SCLowerHex::fmt(&self.token_id, f)
         }
     }
 }

framework/base/src/types/managed/wrapped/token/esdt_token_identifier.rs

@@ -2,11 +2,11 @@ use alloc::string::ToString;
 
 use crate::{
     abi::{TypeAbi, TypeAbiFrom, TypeName},
-    api::{ErrorApi, ErrorApiImpl, HandleConstraints, ManagedTypeApi, ManagedTypeApiImpl},
+    api::{ErrorApi, HandleConstraints, ManagedTypeApi},
     codec::*,
     err_msg,
     formatter::{FormatByteReceiver, SCDisplay, SCLowerHex},
-    types::{ManagedBuffer, ManagedRef, ManagedType},
+    types::{ManagedBuffer, ManagedRef, ManagedType, TokenId},
 };
 
 use super::EgldOrEsdtTokenIdentifier;
@@ -20,7 +20,7 @@ pub type TokenIdentifier<M> = EsdtTokenIdentifier<M>;
 #[repr(transparent)]
 #[derive(Clone)]
 pub struct EsdtTokenIdentifier<M: ErrorApi + ManagedTypeApi> {
-    pub(crate) data: EgldOrEsdtTokenIdentifier<M>,
+    pub(crate) token_id: TokenId<M>,
 }
 
 impl<M: ManagedTypeApi> ManagedType<M> for EsdtTokenIdentifier<M> {
@@ -29,16 +29,16 @@ impl<M: ManagedTypeApi> ManagedType<M> for EsdtTokenIdentifier<M> {
     #[inline]
     unsafe fn from_handle(handle: M::ManagedBufferHandle) -> Self {
         EsdtTokenIdentifier {
-            data: EgldOrEsdtTokenIdentifier::from_handle(handle),
+            token_id: TokenId::from_handle(handle),
         }
     }
 
     fn get_handle(&self) -> M::ManagedBufferHandle {
-        self.data.get_handle()
+        self.token_id.get_handle()
     }
 
     unsafe fn forget_into_handle(self) -> Self::OwnHandle {
-        self.data.forget_into_handle()
+        self.token_id.forget_into_handle()
     }
 
     fn transmute_from_handle_ref(handle_ref: &M::ManagedBufferHandle) -> &Self {
@@ -57,7 +57,9 @@ impl<M: ManagedTypeApi> EsdtTokenIdentifier<M> {
     ///
     /// Calling it for the EGLD token might lead to unexpected bugs.
     pub unsafe fn esdt_unchecked(data: EgldOrEsdtTokenIdentifier<M>) -> Self {
-        Self { data }
+        Self {
+            token_id: data.into(),
+        }
     }
 
     pub fn try_new(data: EgldOrEsdtTokenIdentifier<M>) -> Option<Self> {
@@ -75,30 +77,25 @@ impl<M: ManagedTypeApi> EsdtTokenIdentifier<M> {
 
     #[inline]
     pub fn into_managed_buffer(self) -> ManagedBuffer<M> {
-        self.data.into_managed_buffer()
+        self.token_id.into_managed_buffer()
     }
 
     #[inline]
     pub fn as_managed_buffer(&self) -> &ManagedBuffer<M> {
-        self.data.as_managed_buffer()
+        self.token_id.as_managed_buffer()
     }
 
     #[inline]
     pub fn to_boxed_bytes(&self) -> crate::types::heap::BoxedBytes {
-        self.data.to_boxed_bytes()
+        self.token_id.to_boxed_bytes()
     }
 
     pub fn is_valid_esdt_identifier(&self) -> bool {
-        M::managed_type_impl().validate_token_identifier(self.data.buffer.handle.clone())
+        self.token_id.is_valid()
     }
 
     pub fn ticker(&self) -> ManagedBuffer<M> {
-        let buffer = self.as_managed_buffer();
-        let token_id_len = buffer.len();
-        let ticker_len = M::managed_type_impl().get_token_ticker_len(token_id_len);
-        buffer.copy_slice(0, ticker_len).unwrap_or_else(|| {
-            M::error_api_impl().signal_error(err_msg::BAD_TOKEN_TICKER_FORMAT.as_bytes())
-        })
+        self.token_id.ticker()
     }
 }
 
@@ -109,6 +106,13 @@ impl<M: ManagedTypeApi> From<ManagedBuffer<M>> for EsdtTokenIdentifier<M> {
     }
 }
 
+impl<M: ManagedTypeApi> From<TokenId<M>> for EsdtTokenIdentifier<M> {
+    #[inline]
+    fn from(token_id: TokenId<M>) -> Self {
+        EgldOrEsdtTokenIdentifier::from(token_id).unwrap_esdt()
+    }
+}
+
 impl<M: ManagedTypeApi> From<&[u8]> for EsdtTokenIdentifier<M> {
     fn from(bytes: &[u8]) -> Self {
         EgldOrEsdtTokenIdentifier::from(bytes).unwrap_esdt()
@@ -130,7 +134,7 @@ impl<M: ManagedTypeApi> From<&crate::types::heap::String> for EsdtTokenIdentifie
 impl<M: ManagedTypeApi> PartialEq for EsdtTokenIdentifier<M> {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
-        self.data == other.data
+        self.token_id == other.token_id
     }
 }
 
@@ -154,7 +158,7 @@ impl<M: ManagedTypeApi> NestedEncode for EsdtTokenIdentifier<M> {
         O: NestedEncodeOutput,
         H: EncodeErrorHandler,
     {
-        self.data.dep_encode_or_handle_err(dest, h)
+        self.token_id.dep_encode_or_handle_err(dest, h)
     }
 }
 
@@ -165,7 +169,7 @@ impl<M: ManagedTypeApi> TopEncode for EsdtTokenIdentifier<M> {
         O: TopEncodeOutput,
         H: EncodeErrorHandler,
     {
-        self.data.top_encode_or_handle_err(output, h)
+        self.token_id.top_encode_or_handle_err(output, h)
     }
 }