common_primitives/
handles.rsuse crate::msa::MessageSourceId;
#[cfg(feature = "std")]
use crate::utils::*;
use frame_support::BoundedVec;
use parity_scale_codec::{Decode, DecodeWithMemTracking, Encode};
use scale_info::TypeInfo;
#[cfg(feature = "std")]
use serde::{Deserialize, Serialize};
use sp_core::ConstU32;
extern crate alloc;
use crate::{
node::EIP712Encode, signatures::get_eip712_encoding_prefix, utils::to_abi_compatible_number,
};
use alloc::{boxed::Box, vec::Vec};
use lazy_static::lazy_static;
use sp_core::U256;
pub const HANDLE_CHARS_MIN: u32 = 3;
pub const HANDLE_BYTES_MIN: u32 = 1 * HANDLE_CHARS_MIN;
pub const HANDLE_CHARS_MAX: u32 = 20;
pub const HANDLE_BYTES_MAX: u32 = 32; pub const SUFFIX_MAX_DIGITS: usize = 5; pub const MAX_SUFFIXES_COUNT: u16 = 100;
pub const DEFAULT_SUFFIX_COUNT: u16 = 1;
type Handle = BoundedVec<u8, ConstU32<HANDLE_BYTES_MAX>>;
pub type BaseHandle = Handle;
pub type CanonicalBase = Handle;
pub type DisplayHandle =
BoundedVec<u8, ConstU32<{ HANDLE_BYTES_MAX + SUFFIX_MAX_DIGITS as u32 + 1u32 }>>;
pub type HandleSuffix = u16;
pub type SuffixRangeType = u16;
pub type SequenceIndex = u16;
#[derive(TypeInfo, Clone, Debug, Decode, DecodeWithMemTracking, Encode, PartialEq, Eq)]
pub struct ClaimHandlePayload<BlockNumber> {
pub base_handle: Vec<u8>,
pub expiration: BlockNumber,
}
impl<BlockNumber> ClaimHandlePayload<BlockNumber> {
pub fn new(base_handle: Vec<u8>, expiration: BlockNumber) -> Self {
ClaimHandlePayload { base_handle, expiration }
}
}
impl<BlockNumber> EIP712Encode for ClaimHandlePayload<BlockNumber>
where
BlockNumber: Into<U256> + TryFrom<U256> + Copy,
{
fn encode_eip_712(&self) -> Box<[u8]> {
lazy_static! {
static ref PREFIX_DOMAIN_SEPARATOR: Box<[u8]> =
get_eip712_encoding_prefix("0xcccccccccccccccccccccccccccccccccccccccc");
static ref MAIN_TYPE_HASH: [u8; 32] =
sp_io::hashing::keccak_256(b"ClaimHandlePayload(string handle,uint32 expiration)");
}
let coded_handle = sp_io::hashing::keccak_256(self.base_handle.as_ref());
let expiration: U256 = self.expiration.into();
let coded_expiration = to_abi_compatible_number(expiration.as_u128());
let message = sp_io::hashing::keccak_256(
&[MAIN_TYPE_HASH.as_slice(), &coded_handle, &coded_expiration].concat(),
);
let combined = [PREFIX_DOMAIN_SEPARATOR.as_ref(), &message].concat();
combined.into_boxed_slice()
}
}
#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
#[derive(Clone, Encode, Decode, PartialEq, Debug, TypeInfo, Eq)]
pub struct HandleResponse {
#[cfg_attr(feature = "std", serde(with = "as_string"))]
pub base_handle: Vec<u8>,
#[cfg_attr(feature = "std", serde(with = "as_string"))]
pub canonical_base: Vec<u8>,
pub suffix: HandleSuffix,
}
pub trait HandleProvider {
fn get_handle_for_msa(key: MessageSourceId) -> Option<HandleResponse>;
}
impl HandleProvider for () {
fn get_handle_for_msa(_key: MessageSourceId) -> Option<HandleResponse> {
None
}
}
#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
#[derive(Clone, Encode, Decode, PartialEq, Debug, TypeInfo, Eq)]
pub struct PresumptiveSuffixesResponse {
#[cfg_attr(feature = "std", serde(with = "as_string"))]
pub base_handle: Vec<u8>,
pub suffixes: Vec<HandleSuffix>,
}
#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
#[derive(Clone, Encode, Decode, PartialEq, Debug, TypeInfo, Eq)]
pub struct CheckHandleResponse {
#[cfg_attr(feature = "std", serde(with = "as_string"))]
pub base_handle: Vec<u8>,
#[cfg_attr(feature = "std", serde(with = "as_string"))]
pub canonical_base: Vec<u8>,
pub suffix_index: u16,
pub suffixes_available: bool,
pub valid: bool,
}
impl Default for CheckHandleResponse {
fn default() -> Self {
Self {
base_handle: Vec::new(),
canonical_base: Vec::new(),
suffix_index: 0,
suffixes_available: false,
valid: false,
}
}
}