ink_primitives/
contract.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::types::Environment;
16
17/// Stores the used host environment type of the ink! smart contract.
18///
19/// # Note
20///
21/// The used host environment can be altered using the `env` configuration
22/// parameter in the `#[ink::contract]` parameters. For example if the user
23/// wanted to use an environment type definition called `MyEnvironment` they
24/// issue the ink! smart contract as follows:
25///
26/// ```no_compile
27/// #[ink::contract(env = MyEnvironment)]
28/// ```
29///
30/// # Usage: Default Environment
31///
32/// ```
33/// #[ink::contract]
34/// pub mod contract {
35///     #[ink(storage)]
36///     pub struct Contract {}
37///
38///     impl Contract {
39///         #[ink(constructor)]
40///         pub fn constructor() -> Self {
41///             Self {}
42///         }
43///
44///         #[ink(message)]
45///         pub fn message(&self) {}
46///     }
47/// }
48///
49/// use contract::Contract;
50///
51/// # use ink::env::ContractEnv;
52/// # use ink::codegen::utils::IsSameType;
53///
54/// // The following line only compiles successfully if both
55/// // `ink_env::DefaultEnvironment` and `<Contract as ContractEnv>::Env`
56/// // are of the same type.
57/// const _: IsSameType<<Contract as ContractEnv>::Env> =
58///     <IsSameType<ink_env::DefaultEnvironment>>::new();
59/// ```
60///
61/// # Usage: Custom Environment
62///
63/// ```
64/// # use ink_env::{Environment, DefaultEnvironment};
65/// #[derive(Clone)]
66/// pub struct CustomEnvironment {}
67///
68/// impl Environment for CustomEnvironment {
69///     const NATIVE_TO_ETH_RATIO: u32 =
70///         <DefaultEnvironment as Environment>::NATIVE_TO_ETH_RATIO;
71///
72///     type AccountId = <DefaultEnvironment as Environment>::AccountId;
73///     type Balance = u64;
74///     type Hash = <DefaultEnvironment as Environment>::Hash;
75///     type BlockNumber = u32;
76///     type Timestamp = u64;
77///     type EventRecord = <DefaultEnvironment as Environment>::EventRecord;
78/// }
79///
80/// #[ink::contract(env = super::CustomEnvironment)]
81/// pub mod contract {
82///     #[ink(storage)]
83///     pub struct Contract {}
84///
85///     impl Contract {
86///         #[ink(constructor)]
87///         pub fn constructor() -> Self {
88///             Self {}
89///         }
90///
91///         #[ink(message)]
92///         pub fn message(&self) {}
93///     }
94/// }
95///
96/// use contract::Contract;
97/// # use ink::env::ContractEnv;
98/// # use ink::codegen::utils::IsSameType;
99///
100/// // The following line only compiles successfully if both
101/// // `CustomEnvironment` and `<Contract as ContractEnv>::Env`
102/// // are of the same type.
103/// const _: IsSameType<<Contract as ContractEnv>::Env> =
104///     <IsSameType<CustomEnvironment>>::new();
105///
106/// fn main() {}
107/// ```
108pub trait ContractEnv {
109    /// The environment type.
110    type Env: Environment;
111}
112
113/// Refers to the generated ink! smart contract reference type.
114///
115/// # Note
116///
117/// Given an ink! storage struct with identifier `Contract` the ink! codegen produces
118/// the ink! root type `Contract` and the ink! reference type `ContractRef`.
119///
120/// This trait exists so that users can avoid using a generated identifier to refer to
121/// the generated reference type of the ink! smart contract.
122///
123/// # Usage
124///
125/// ```
126/// #[ink::contract]
127/// pub mod contract {
128///     #[ink(storage)]
129///     pub struct Contract {}
130///
131///     impl Contract {
132///         #[ink(constructor)]
133///         pub fn constructor() -> Self {
134///             Self {}
135///         }
136///
137///         #[ink(message)]
138///         pub fn message(&self) {}
139///     }
140/// }
141///
142/// use contract::{
143///     Contract,
144///     ContractRef,
145/// };
146/// # use ink::codegen::utils::IsSameType;
147/// # use ink::env::ContractReference;
148///
149/// // The following line only compiles successfully if both
150/// // `ContractReference` and `<Contract as ContractReference>::Type`
151/// // are of the same type.
152/// const _: IsSameType<<Contract as ContractReference>::Type> =
153///     <IsSameType<ContractRef>>::new();
154/// ```
155pub trait ContractReference {
156    /// The generated contract reference type.
157    type Type;
158}
159
160/// Refers back to the original contract from the generated ink! smart contract
161/// reference type.
162pub trait ContractReverseReference {
163    /// The original contract type.
164    type Type;
165}
ink_primitives/contract.rs

ink_primitives/
contract.rs
