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 106 107 108 109 110 111 112 113 114 115 116 117 118
use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use crate::addresses::HumanAddr; use crate::coins::Coin; #[derive(Serialize, Deserialize, Clone, Default, Debug, PartialEq, JsonSchema)] pub struct Env { pub block: BlockInfo, pub contract: ContractInfo, } #[derive(Serialize, Deserialize, Clone, Default, Debug, PartialEq, JsonSchema)] 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::{BlockInfo, ContractInfo, Env, HumanAddr, 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: HumanAddr::from("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::{BlockInfo, ContractInfo, Env, HumanAddr, 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: HumanAddr::from("contract"), /// # }, /// # }; /// let millis = (env.block.time * 1_000) + (env.block.time_nanos / 1_000_000); /// ``` pub time_nanos: u64, pub chain_id: String, } /// MessageInfo is sent with `init`, `handle`, and `migrate` calls, but not with queries. /// It contains the essential info for authorization - identity of the call, and payment #[derive(Serialize, Deserialize, Clone, Default, Debug, PartialEq, JsonSchema)] pub struct MessageInfo { /// The `sender` field from the `wasm/MsgStoreCode`, `wasm/MsgInstantiateContract`, `wasm/MsgMigrateContract` /// or `wasm/MsgExecuteContract` message. /// 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. /// Additional signers of the transaction that are either needed for other messages or contain unnecessary /// signatures are not propagated into the contract. /// /// There is a discussion to open up this field to multiple initiators, which you're welcome to join /// if you have a specific need for that feature: https://github.com/CosmWasm/cosmwasm/issues/293 pub sender: HumanAddr, pub sent_funds: Vec<Coin>, } #[derive(Serialize, Deserialize, Clone, Default, Debug, PartialEq, JsonSchema)] pub struct ContractInfo { pub address: HumanAddr, } /// An empty struct that serves as a placeholder in different places, /// such as contracts that don't set a custom message. /// /// It is designed to be expressable in correct JSON and JSON Schema but /// contains no meaningful data. Previously we used enums without cases, /// but those cannot represented as valid JSON Schema (https://github.com/CosmWasm/cosmwasm/issues/451) #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)] pub struct Empty {} #[cfg(test)] mod tests { use super::*; use crate::serde::{from_slice, to_vec}; #[test] fn empty_can_be_instantiated_serialized_and_deserialized() { let instance = Empty {}; let serialized = to_vec(&instance).unwrap(); assert_eq!(serialized, b"{}"); let deserialized: Empty = from_slice(b"{}").unwrap(); assert_eq!(deserialized, instance); let deserialized: Empty = from_slice(b"{\"stray\":\"data\"}").unwrap(); assert_eq!(deserialized, instance); } }