ink_primitives/
types.rs

1// Copyright (C) Use Ink (UK) Ltd.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use crate::arithmetic::AtLeast32BitUnsigned;
16use alloy_sol_types::{
17    private::{
18        Address as SolAddress,
19        FixedBytes,
20    },
21    sol_data,
22    SolValue,
23};
24use core::{
25    array::TryFromSliceError,
26    borrow::Borrow,
27};
28use derive_more::From;
29use primitive_types::{
30    H160,
31    U256,
32};
33use scale::{
34    Decode,
35    Encode,
36    MaxEncodedLen,
37};
38use sp_core::keccak_256;
39#[cfg(feature = "std")]
40use {
41    scale_decode::DecodeAsType,
42    scale_encode::EncodeAsType,
43    scale_info::TypeInfo,
44};
45
46/// The default environment `AccountId` type.
47///
48/// # Note
49///
50/// This is a mirror of the `AccountId` type used in the default configuration
51/// of PALLET contracts.
52#[derive(
53    Debug,
54    Copy,
55    Clone,
56    PartialEq,
57    Eq,
58    Ord,
59    PartialOrd,
60    Hash,
61    Decode,
62    Encode,
63    MaxEncodedLen,
64    From,
65)]
66#[cfg_attr(feature = "std", derive(TypeInfo, DecodeAsType, EncodeAsType))]
67pub struct AccountId(pub [u8; 32]);
68
69impl AsRef<[u8; 32]> for AccountId {
70    #[inline]
71    fn as_ref(&self) -> &[u8; 32] {
72        &self.0
73    }
74}
75
76impl AsMut<[u8; 32]> for AccountId {
77    #[inline]
78    fn as_mut(&mut self) -> &mut [u8; 32] {
79        &mut self.0
80    }
81}
82
83impl AsRef<[u8]> for AccountId {
84    #[inline]
85    fn as_ref(&self) -> &[u8] {
86        &self.0[..]
87    }
88}
89
90impl AsMut<[u8]> for AccountId {
91    #[inline]
92    fn as_mut(&mut self) -> &mut [u8] {
93        &mut self.0[..]
94    }
95}
96
97impl<'a> TryFrom<&'a [u8]> for AccountId {
98    type Error = TryFromSliceError;
99
100    fn try_from(bytes: &'a [u8]) -> Result<Self, TryFromSliceError> {
101        let address = <[u8; 32]>::try_from(bytes)?;
102        Ok(Self(address))
103    }
104}
105
106impl Borrow<[u8; 32]> for AccountId {
107    fn borrow(&self) -> &[u8; 32] {
108        &self.0
109    }
110}
111
112impl SolValue for AccountId {
113    type SolType = sol_data::FixedBytes<32>;
114
115    #[inline]
116    fn abi_encode(&self) -> ink_prelude::vec::Vec<u8> {
117        self.0.as_slice().abi_encode()
118    }
119}
120
121impl From<FixedBytes<32>> for AccountId {
122    fn from(value: FixedBytes<32>) -> Self {
123        AccountId(value.0)
124    }
125}
126
127/// The default environment `Hash` type.
128///
129/// # Note
130///
131/// This is a mirror of the `Hash` type used in the default configuration
132/// of PALLET contracts.
133#[derive(
134    Debug,
135    Copy,
136    Clone,
137    PartialEq,
138    Eq,
139    Ord,
140    PartialOrd,
141    Hash,
142    Decode,
143    Encode,
144    MaxEncodedLen,
145    From,
146    Default,
147)]
148#[cfg_attr(feature = "std", derive(TypeInfo, DecodeAsType, EncodeAsType))]
149pub struct Hash([u8; 32]);
150
151impl<'a> TryFrom<&'a [u8]> for Hash {
152    type Error = TryFromSliceError;
153
154    fn try_from(bytes: &'a [u8]) -> Result<Self, TryFromSliceError> {
155        let hash = <[u8; 32]>::try_from(bytes)?;
156        Ok(Self(hash))
157    }
158}
159
160impl AsRef<[u8]> for Hash {
161    fn as_ref(&self) -> &[u8] {
162        &self.0[..]
163    }
164}
165
166impl AsMut<[u8]> for Hash {
167    fn as_mut(&mut self) -> &mut [u8] {
168        &mut self.0[..]
169    }
170}
171
172impl From<Hash> for [u8; 32] {
173    fn from(hash: Hash) -> Self {
174        hash.0
175    }
176}
177
178impl Borrow<[u8; 32]> for Hash {
179    fn borrow(&self) -> &[u8; 32] {
180        &self.0
181    }
182}
183
184impl SolValue for Hash {
185    type SolType = sol_data::FixedBytes<32>;
186
187    #[inline]
188    fn abi_encode(&self) -> ink_prelude::vec::Vec<u8> {
189        self.0.abi_encode()
190    }
191}
192
193impl From<FixedBytes<32>> for Hash {
194    fn from(value: FixedBytes<32>) -> Self {
195        Hash(value.0)
196    }
197}
198
199/// The equivalent of `Zero` for hashes.
200///
201/// A hash that consists only of 0 bits is clear.
202pub trait Clear {
203    /// The clear hash.
204    const CLEAR_HASH: Self;
205
206    /// Returns `true` if the hash is clear.
207    fn is_clear(&self) -> bool;
208}
209
210impl Clear for [u8; 32] {
211    const CLEAR_HASH: Self = [0x00; 32];
212
213    fn is_clear(&self) -> bool {
214        self == &Self::CLEAR_HASH
215    }
216}
217
218impl Clear for Hash {
219    const CLEAR_HASH: Self = Self(<[u8; 32] as Clear>::CLEAR_HASH);
220
221    fn is_clear(&self) -> bool {
222        <[u8; 32] as Clear>::is_clear(&self.0)
223    }
224}
225
226// impl Clear for H256 {
227// const CLEAR_HASH: Self = H256::CLEAR_HASH;
228//
229// fn is_clear(&self) -> bool {
230// self.as_bytes().iter().all(|&byte| byte == 0x00)
231// }
232// }
233
234#[derive(Debug, Clone, Eq, PartialEq, Encode, Decode)]
235#[cfg_attr(
236    feature = "std",
237    derive(
238        scale_info::TypeInfo,
239        EncodeAsType,
240        serde::Serialize,
241        serde::Deserialize
242    )
243)]
244pub enum DepositLimit<Balance> {
245    /// Allows bypassing all balance transfer checks.
246    Unchecked,
247
248    /// Specifies a maximum allowable balance for a deposit.
249    Balance(Balance),
250}
251
252impl<T> From<T> for DepositLimit<T> {
253    fn from(value: T) -> Self {
254        Self::Balance(value)
255    }
256}
257
258/// Allows to instantiate a type from its little-endian bytes representation.
259pub trait FromLittleEndian {
260    /// The little-endian bytes representation.
261    type Bytes: Default + AsRef<[u8]> + AsMut<[u8]>;
262
263    /// Create a new instance from the little-endian bytes representation.
264    fn from_le_bytes(bytes: Self::Bytes) -> Self;
265}
266
267impl FromLittleEndian for u8 {
268    type Bytes = [u8; 1];
269
270    #[inline]
271    fn from_le_bytes(bytes: Self::Bytes) -> Self {
272        u8::from_le_bytes(bytes)
273    }
274}
275
276impl FromLittleEndian for u16 {
277    type Bytes = [u8; 2];
278
279    #[inline]
280    fn from_le_bytes(bytes: Self::Bytes) -> Self {
281        u16::from_le_bytes(bytes)
282    }
283}
284
285impl FromLittleEndian for u32 {
286    type Bytes = [u8; 4];
287
288    #[inline]
289    fn from_le_bytes(bytes: Self::Bytes) -> Self {
290        u32::from_le_bytes(bytes)
291    }
292}
293
294impl FromLittleEndian for u64 {
295    type Bytes = [u8; 8];
296
297    #[inline]
298    fn from_le_bytes(bytes: Self::Bytes) -> Self {
299        u64::from_le_bytes(bytes)
300    }
301}
302
303impl FromLittleEndian for u128 {
304    type Bytes = [u8; 16];
305
306    #[inline]
307    fn from_le_bytes(bytes: Self::Bytes) -> Self {
308        u128::from_le_bytes(bytes)
309    }
310}
311
312impl FromLittleEndian for U256 {
313    type Bytes = [u8; 32];
314
315    #[inline]
316    fn from_le_bytes(bytes: Self::Bytes) -> Self {
317        U256::from_little_endian(&bytes)
318        //U256::from_le_bytes(bytes)
319    }
320}
321
322/// todo remove
323/// A trait to enforce that a type should be an [`Environment::AccountId`].
324///
325/// If you have an [`Environment`] which uses an [`Environment::AccountId`] type other
326/// than the ink! provided [`AccountId`](https://docs.rs/ink_primitives/latest/ink_primitives/struct.AccountId.html)
327/// you will need to implement this trait for your [`Environment::AccountId`] concrete
328/// type.
329pub trait AccountIdGuard {}
330
331/// The ink! provided [`AccountId`](https://docs.rs/ink_primitives/latest/ink_primitives/struct.AccountId.html)
332/// used in the [`DefaultEnvironment`].
333impl AccountIdGuard for AccountId {}
334
335impl AccountIdGuard for H160 {}
336
337cfg_if::cfg_if! {
338    if #[cfg(feature = "std")] {
339        pub trait CodecAsType: scale_decode::DecodeAsType + scale_encode::EncodeAsType {}
340        impl<T: scale_decode::DecodeAsType + scale_encode::EncodeAsType> CodecAsType for T {}
341    } else {
342        pub trait CodecAsType {}
343        impl<T> CodecAsType for T {}
344    }
345}
346
347/// The environmental types usable by contracts defined with ink!.
348pub trait Environment: Clone {
349    /// The maximum number of supported event topics provided by the runtime.
350    ///
351    /// The value must match the maximum number of supported event topics of the used
352    /// runtime.
353    const MAX_EVENT_TOPICS: usize;
354
355    /// The account id type.
356    type AccountId: 'static
357        + scale::Codec
358        + scale::MaxEncodedLen
359        + CodecAsType
360        + Clone
361        + PartialEq
362        + Eq
363        + Ord
364        + AsRef<[u8]>
365        + AsMut<[u8]>;
366
367    /// The type of balances.
368    type Balance: 'static
369        + scale::Codec
370        + CodecAsType
371        + Copy
372        + Clone
373        + PartialEq
374        + Eq
375        + AtLeast32BitUnsigned
376        + FromLittleEndian;
377
378    /// The type of hash.
379    type Hash: 'static
380        + scale::Codec
381        + scale::MaxEncodedLen
382        + CodecAsType
383        + Copy
384        + Clone
385        + Clear
386        + PartialEq
387        + Eq
388        + Ord
389        + AsRef<[u8]>
390        + AsMut<[u8]>;
391
392    /// The type of a timestamp.
393    type Timestamp: 'static
394        + scale::Codec
395        + CodecAsType
396        + Copy
397        + Clone
398        + PartialEq
399        + Eq
400        + AtLeast32BitUnsigned
401        + FromLittleEndian;
402
403    /// The type of block number.
404    type BlockNumber: 'static
405        + scale::Codec
406        + CodecAsType
407        + Copy
408        + Clone
409        + PartialEq
410        + Eq
411        + AtLeast32BitUnsigned
412        + FromLittleEndian;
413
414    /// The chain extension for the environment.
415    ///
416    /// This is a type that is defined through the `#[ink::chain_extension]` procedural
417    /// macro. For more information about usage and definition click
418    /// [this][chain_extension] link.
419    ///
420    /// [chain_extension]: https://use-ink.github.io/ink/ink/attr.chain_extension.html
421    type ChainExtension;
422
423    /// TODO comment
424    type EventRecord: 'static + scale::Codec;
425}
426
427/// Placeholder for chains that have no defined chain extension.
428#[cfg_attr(feature = "std", derive(TypeInfo))]
429pub enum NoChainExtension {}
430
431/// The fundamental types of the default configuration.
432#[derive(Debug, Clone, PartialEq, Eq)]
433#[cfg_attr(feature = "std", derive(TypeInfo))]
434pub enum DefaultEnvironment {}
435
436impl Environment for DefaultEnvironment {
437    const MAX_EVENT_TOPICS: usize = 4;
438
439    type AccountId = AccountId;
440    type Balance = Balance;
441    type Hash = Hash;
442    type Timestamp = Timestamp;
443    type BlockNumber = BlockNumber;
444    type ChainExtension = NoChainExtension;
445    type EventRecord = EventRecord;
446}
447
448/// The default balance type.
449pub type Balance = u128;
450
451/// The default timestamp type.
452pub type Timestamp = u64;
453
454/// The default gas type.
455pub type Gas = u64;
456
457/// The default block number type.
458pub type BlockNumber = u32;
459
460// todo replace with ()
461#[derive(Encode, Decode, MaxEncodedLen, Debug)]
462pub struct RuntimeEvent();
463
464/// The default event record type.
465pub type EventRecord = EventRecordFoo<RuntimeEvent, Hash>;
466
467#[derive(Encode, Decode, Debug)]
468#[cfg_attr(feature = "std", derive(TypeInfo))]
469pub struct EventRecordFoo<E, H> {
470    /// The phase of the block it happened in.
471    pub phase: Phase,
472    /// The event itself.
473    pub event: E,
474    /// The list of the topics this event has.
475    pub topics: ink_prelude::vec::Vec<H>,
476}
477
478/// A phase of a block's execution.
479#[derive(Debug, Encode, Decode, MaxEncodedLen)]
480#[cfg_attr(feature = "std", derive(PartialEq, Eq, Clone, TypeInfo))]
481pub enum Phase {
482    /// Applying an extrinsic.
483    ApplyExtrinsic(u32),
484    /// Finalizing the block.
485    Finalization,
486    /// Initializing the block.
487    Initialization,
488}
489
490/// The type of origins supported by `pallet-revive`.
491#[derive(Clone, ::scale::Encode, ::scale::Decode, PartialEq)]
492#[cfg_attr(feature = "std", derive(::scale_info::TypeInfo))]
493pub enum Origin<E: Environment> {
494    Root,
495    Signed(E::AccountId),
496}
497
498pub struct AccountIdMapper {}
499impl AccountIdMapper {
500    //pub fn to_address(account_id: &E::AccountId) -> H160 {
501    pub fn to_address(account_id: &[u8]) -> H160 {
502        let mut account_bytes: [u8; 32] = [0u8; 32];
503        account_bytes.copy_from_slice(&account_id[..32]);
504        if Self::is_eth_derived(account_id) {
505            // this was originally an eth address
506            // we just strip the 0xEE suffix to get the original address
507            H160::from_slice(&account_bytes[..20])
508        } else {
509            // this is an (ed|sr)25510 derived address
510            // avoid truncating the public key by hashing it first
511            let account_hash = keccak_256(account_bytes.as_ref());
512            H160::from_slice(&account_hash[12..])
513        }
514    }
515
516    /// Returns true if the passed account id is controlled by an Ethereum key.
517    ///
518    /// This is a stateless check that just compares the last 12 bytes. Please note that
519    /// it is theoretically possible to create an ed25519 keypair that passed this
520    /// filter. However, this can't be used for an attack. It also won't happen by
521    /// accident since everbody is using sr25519 where this is not a valid public key.
522    //fn is_eth_derived(account_id: &[u8]) -> bool {
523    fn is_eth_derived(account_bytes: &[u8]) -> bool {
524        account_bytes[20..] == [0xEE; 12]
525    }
526}
527
528/// A Solidity compatible `address` type.
529#[derive(
530    Debug,
531    Copy,
532    Clone,
533    PartialEq,
534    Eq,
535    Ord,
536    PartialOrd,
537    Hash,
538    Decode,
539    Encode,
540    MaxEncodedLen,
541    From,
542)]
543#[cfg_attr(feature = "std", derive(TypeInfo, DecodeAsType, EncodeAsType))]
544pub struct Address(pub [u8; 20]);
545
546impl AsRef<[u8; 20]> for Address {
547    fn as_ref(&self) -> &[u8; 20] {
548        &self.0
549    }
550}
551
552impl AsMut<[u8; 20]> for Address {
553    fn as_mut(&mut self) -> &mut [u8; 20] {
554        &mut self.0
555    }
556}
557
558impl AsRef<[u8]> for Address {
559    fn as_ref(&self) -> &[u8] {
560        &self.0[..]
561    }
562}
563
564impl AsMut<[u8]> for Address {
565    fn as_mut(&mut self) -> &mut [u8] {
566        &mut self.0[..]
567    }
568}
569
570impl<'a> TryFrom<&'a [u8]> for Address {
571    type Error = TryFromSliceError;
572
573    fn try_from(bytes: &'a [u8]) -> Result<Self, TryFromSliceError> {
574        let address = <[u8; 20]>::try_from(bytes)?;
575        Ok(Self(address))
576    }
577}
578
579impl Borrow<[u8; 20]> for Address {
580    fn borrow(&self) -> &[u8; 20] {
581        &self.0
582    }
583}
584
585impl SolValue for Address {
586    type SolType = sol_data::Address;
587
588    #[inline]
589    fn abi_encode(&self) -> ink_prelude::vec::Vec<u8> {
590        self.0.as_slice().abi_encode()
591    }
592}
593
594impl From<SolAddress> for Address {
595    fn from(value: SolAddress) -> Self {
596        Address(value.into_array())
597    }
598}
ink_primitives/types.rs

ink_primitives/
types.rs
