1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
use serde::{Deserialize, Serialize}; use crate::addresses::Addr; use crate::coins::Coin; use crate::timestamp::Timestamp; #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] pub struct Env { pub block: BlockInfo, pub contract: ContractInfo, } #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] pub struct BlockInfo { pub height: u64, /// Absolute time of the block creation in seconds since the UNIX epoch (00:00:00 on 1970-01-01 UTC). /// /// The source of this is the [BFT Time in Tendermint](https://docs.tendermint.com/master/spec/consensus/bft-time.html), /// converted from nanoseconds to second precision by truncating the fractioal part. pub time: u64, /// The fractional part of the block time in nanoseconds since `time` (0 to 999999999). /// Add this to `time` if you need a high precision block time. /// /// # Examples /// /// Using chrono: /// /// ``` /// # use cosmwasm_std::{Addr, BlockInfo, ContractInfo, Env, MessageInfo}; /// # let env = Env { /// # block: BlockInfo { /// # height: 12_345, /// # time: 1_571_797_419, /// # time_nanos: 879305533, /// # chain_id: "cosmos-testnet-14002".to_string(), /// # }, /// # contract: ContractInfo { /// # address: Addr::unchecked("contract"), /// # }, /// # }; /// # extern crate chrono; /// use chrono::NaiveDateTime; /// let dt = NaiveDateTime::from_timestamp(env.block.time as i64, env.block.time_nanos as u32); /// ``` /// /// Creating a simple millisecond-precision timestamp (as used in JavaScript): /// /// ``` /// # use cosmwasm_std::{Addr, BlockInfo, ContractInfo, Env, MessageInfo}; /// # let env = Env { /// # block: BlockInfo { /// # height: 12_345, /// # time: 1_571_797_419, /// # time_nanos: 879305533, /// # chain_id: "cosmos-testnet-14002".to_string(), /// # }, /// # contract: ContractInfo { /// # address: Addr::unchecked("contract"), /// # }, /// # }; /// let millis = (env.block.time * 1_000) + (env.block.time_nanos / 1_000_000); /// ``` pub time_nanos: u64, pub chain_id: String, } impl BlockInfo { /// Returns the block creation time as a Timestamp in nanosecond precision pub fn timestamp(&self) -> Timestamp { Timestamp { seconds: self.time, nanos: self.time_nanos, } } } /// Additional information from [MsgInstantiateContract] and [MsgExecuteContract], which is passed /// along with the contract execution message into the `instantiate` and `execute` entry points. /// /// It contains the essential info for authorization - identity of the call, and payment. /// /// [MsgInstantiateContract]: https://github.com/CosmWasm/wasmd/blob/v0.15.0/x/wasm/internal/types/tx.proto#L47-L61 /// [MsgExecuteContract]: https://github.com/CosmWasm/wasmd/blob/v0.15.0/x/wasm/internal/types/tx.proto#L68-L78 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] pub struct MessageInfo { /// The `sender` field from `MsgInstantiateContract` and `MsgExecuteContract`. /// You can think of this as the address that initiated the action (i.e. the message). What that /// means exactly heavily depends on the application. /// /// The x/wasm module ensures that the sender address signed the transaction or /// is otherwise authorized to send the message. /// /// Additional signers of the transaction that are either needed for other messages or contain unnecessary /// signatures are not propagated into the contract. pub sender: Addr, /// The funds that are sent to the contract as part of `MsgInstantiateContract` /// or `MsgExecuteContract`. The transfer is processed in bank before the contract /// is executed such that the new balance is visible during contract execution. pub funds: Vec<Coin>, } #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] pub struct ContractInfo { pub address: Addr, }