Refactor Timestamps

CHANGELOG.md

@@ -73,6 +73,11 @@ and this project adheres to
   contract (eg. multisig) to clear the admin, to prevent future migrations
   ([#900])
 - cosmwasm-std: Implement `Display for Coin` ([#901]).
+- cosmwasm-std: Create `Uint64` analogously to `Uint128` with string
+  serialization allowing the use of the full uint64 range in JSON clients that
+  use float numbers, such as JavaScript and jq.
+- cosmwasm-std: Create const functions `Uint64::new` and `Uint128::new` to
+  create instances in a const context.
 
 [#692]: https://github.com/CosmWasm/cosmwasm/issues/692
 [#706]: https://github.com/CosmWasm/cosmwasm/pull/706

IBC.md

@@ -37,21 +37,24 @@ pub enum IbcMsg {
     }
 }
 
+/// In IBC each package must set at least one type of timeout:
+/// the timestamp or the block height. Using this rather complex enum instead of
+/// two timeout fields we ensure that at least one timeout is set.
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum IbcTimeout {
-    /// block timestamp (nanoseconds since UNIX epoch) after which the packet times out
-    /// (measured on the remote chain)
-    /// See https://golang.org/pkg/time/#Time.UnixNano
-    TimestampNanos(u64),
-    /// block after which the packet times out (measured on remote chain)
+    /// Block timestamp (nanoseconds since UNIX epoch) after which the packet times out
+    /// (measured on the remote chain).
+    Timestamp(Timestamp),
+    /// Block after which the packet times out (measured on remote chain).
     Block(IbcTimeoutBlock),
+    /// Use this to set both timestamp and block timeout. The package then times out once
+    /// the first of both timeouts is hit.
     Both {
-        timestamp_nanos: u64,
+        timestamp: Timestamp,
         block: IbcTimeoutBlock,
     },
 }
-
 ```
 
 Note the `to_address` is likely not a valid `Addr`, as it uses the bech32 prefix

contracts/crypto-verify/schema/query_msg.json

@@ -255,6 +255,7 @@
       "type": "string"
     },
     "Uint128": {
+      "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
       "type": "string"
     }
   }

contracts/hackatom/schema/balance_response.json

@@ -32,6 +32,7 @@
       }
     },
     "Uint128": {
+      "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
       "type": "string"
     }
   }

contracts/hackatom/schema/sudo_msg.json

@@ -48,6 +48,7 @@
       }
     },
     "Uint128": {
+      "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
       "type": "string"
     }
   }

contracts/ibc-reflect-send/schema/account_response.json

@@ -44,6 +44,7 @@
       }
     },
     "Uint128": {
+      "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
       "type": "string"
     }
   }

contracts/ibc-reflect-send/schema/execute_msg.json

@@ -435,24 +435,23 @@
       ]
     },
     "IbcTimeout": {
+      "description": "In IBC each package must set at least one type of timeout: the timestamp or the block height. Using this rather complex enum instead of two timeout fields we ensure that at least one timeout is set.",
       "anyOf": [
         {
-          "description": "block timestamp (nanoseconds since UNIX epoch) after which the packet times out (measured on the remote chain) See https://golang.org/pkg/time/#Time.UnixNano",
+          "description": "Block timestamp (nanoseconds since UNIX epoch) after which the packet times out (measured on the remote chain).",
           "type": "object",
           "required": [
-            "timestamp_nanos"
+            "timestamp"
           ],
           "properties": {
-            "timestamp_nanos": {
-              "type": "integer",
-              "format": "uint64",
-              "minimum": 0.0
+            "timestamp": {
+              "$ref": "#/definitions/Timestamp"
             }
           },
           "additionalProperties": false
         },
         {
-          "description": "block after which the packet times out (measured on remote chain)",
+          "description": "Block after which the packet times out (measured on remote chain).",
           "type": "object",
           "required": [
             "block"
@@ -465,6 +464,7 @@
           "additionalProperties": false
         },
         {
+          "description": "Use this to set both timestamp and block timeout. The package then times out once the first of both timeouts is hit.",
           "type": "object",
           "required": [
             "both"
@@ -474,16 +474,14 @@
               "type": "object",
               "required": [
                 "block",
-                "timestamp_nanos"
+                "timestamp"
               ],
               "properties": {
                 "block": {
                   "$ref": "#/definitions/IbcTimeoutBlock"
                 },
-                "timestamp_nanos": {
-                  "type": "integer",
-                  "format": "uint64",
-                  "minimum": 0.0
+                "timestamp": {
+                  "$ref": "#/definitions/Timestamp"
                 }
               }
             }
@@ -598,7 +596,20 @@
         }
       ]
     },
+    "Timestamp": {
+      "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.",
+      "allOf": [
+        {
+          "$ref": "#/definitions/Uint64"
+        }
+      ]
+    },
     "Uint128": {
+      "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
+      "type": "string"
+    },
+    "Uint64": {
+      "description": "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```",
       "type": "string"
     },
     "WasmMsg": {

contracts/ibc-reflect-send/schema/list_accounts_response.json

@@ -62,6 +62,7 @@
       }
     },
     "Uint128": {
+      "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
       "type": "string"
     }
   }

contracts/ibc-reflect-send/schema/packet_msg.json

@@ -388,24 +388,23 @@
       ]
     },
     "IbcTimeout": {
+      "description": "In IBC each package must set at least one type of timeout: the timestamp or the block height. Using this rather complex enum instead of two timeout fields we ensure that at least one timeout is set.",
       "anyOf": [
         {
-          "description": "block timestamp (nanoseconds since UNIX epoch) after which the packet times out (measured on the remote chain) See https://golang.org/pkg/time/#Time.UnixNano",
+          "description": "Block timestamp (nanoseconds since UNIX epoch) after which the packet times out (measured on the remote chain).",
           "type": "object",
           "required": [
-            "timestamp_nanos"
+            "timestamp"
           ],
           "properties": {
-            "timestamp_nanos": {
-              "type": "integer",
-              "format": "uint64",
-              "minimum": 0.0
+            "timestamp": {
+              "$ref": "#/definitions/Timestamp"
             }
           },
           "additionalProperties": false
         },
         {
-          "description": "block after which the packet times out (measured on remote chain)",
+          "description": "Block after which the packet times out (measured on remote chain).",
           "type": "object",
           "required": [
             "block"
@@ -418,6 +417,7 @@
           "additionalProperties": false
         },
         {
+          "description": "Use this to set both timestamp and block timeout. The package then times out once the first of both timeouts is hit.",
           "type": "object",
           "required": [
             "both"
@@ -427,16 +427,14 @@
               "type": "object",
               "required": [
                 "block",
-                "timestamp_nanos"
+                "timestamp"
               ],
               "properties": {
                 "block": {
                   "$ref": "#/definitions/IbcTimeoutBlock"
                 },
-                "timestamp_nanos": {
-                  "type": "integer",
-                  "format": "uint64",
-                  "minimum": 0.0
+                "timestamp": {
+                  "$ref": "#/definitions/Timestamp"
                 }
               }
             }
@@ -551,7 +549,20 @@
         }
       ]
     },
+    "Timestamp": {
+      "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.",
+      "allOf": [
+        {
+          "$ref": "#/definitions/Uint64"
+        }
+      ]
+    },
     "Uint128": {
+      "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
+      "type": "string"
+    },
+    "Uint64": {
+      "description": "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```",
       "type": "string"
     },
     "WasmMsg": {

contracts/ibc-reflect-send/src/ibc.rs

@@ -445,7 +445,7 @@ mod tests {
                 assert_eq!(transfer_channel_id, channel_id.as_str());
                 assert_eq!(remote_addr, to_address.as_str());
                 assert_eq!(&coin(12344, "utrgd"), amount);
-                assert!(matches!(timeout, IbcTimeout::TimestampNanos { .. }));
+                assert!(matches!(timeout, IbcTimeout::Timestamp { .. }));
             }
             o => panic!("unexpected message: {:?}", o),
         }

contracts/ibc-reflect-send/tests/integration.rs

@@ -239,7 +239,7 @@ fn send_remote_funds() {
             assert_eq!(transfer_channel_id, channel_id.as_str());
             assert_eq!(remote_addr, to_address.as_str());
             assert_eq!(&coin(12344, "utrgd"), amount);
-            assert!(matches!(timeout, IbcTimeout::TimestampNanos { .. }));
+            assert!(matches!(timeout, IbcTimeout::Timestamp { .. }));
         }
         o => panic!("unexpected message: {:?}", o),
     }

contracts/ibc-reflect/schema/acknowledgement_msg_balances.json

@@ -65,6 +65,7 @@
       }
     },
     "Uint128": {
+      "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
       "type": "string"
     }
   }

contracts/ibc-reflect/schema/packet_msg.json

@@ -387,24 +387,23 @@
       ]
     },
     "IbcTimeout": {
+      "description": "In IBC each package must set at least one type of timeout: the timestamp or the block height. Using this rather complex enum instead of two timeout fields we ensure that at least one timeout is set.",
       "anyOf": [
         {
-          "description": "block timestamp (nanoseconds since UNIX epoch) after which the packet times out (measured on the remote chain) See https://golang.org/pkg/time/#Time.UnixNano",
+          "description": "Block timestamp (nanoseconds since UNIX epoch) after which the packet times out (measured on the remote chain).",
           "type": "object",
           "required": [
-            "timestamp_nanos"
+            "timestamp"
           ],
           "properties": {
-            "timestamp_nanos": {
-              "type": "integer",
-              "format": "uint64",
-              "minimum": 0.0
+            "timestamp": {
+              "$ref": "#/definitions/Timestamp"
             }
           },
           "additionalProperties": false
         },
         {
-          "description": "block after which the packet times out (measured on remote chain)",
+          "description": "Block after which the packet times out (measured on remote chain).",
           "type": "object",
           "required": [
             "block"
@@ -417,6 +416,7 @@
           "additionalProperties": false
         },
         {
+          "description": "Use this to set both timestamp and block timeout. The package then times out once the first of both timeouts is hit.",
           "type": "object",
           "required": [
             "both"
@@ -426,16 +426,14 @@
               "type": "object",
               "required": [
                 "block",
-                "timestamp_nanos"
+                "timestamp"
               ],
               "properties": {
                 "block": {
                   "$ref": "#/definitions/IbcTimeoutBlock"
                 },
-                "timestamp_nanos": {
-                  "type": "integer",
-                  "format": "uint64",
-                  "minimum": 0.0
+                "timestamp": {
+                  "$ref": "#/definitions/Timestamp"
                 }
               }
             }
@@ -550,7 +548,20 @@
         }
       ]
     },
+    "Timestamp": {
+      "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.",
+      "allOf": [
+        {
+          "$ref": "#/definitions/Uint64"
+        }
+      ]
+    },
     "Uint128": {
+      "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
+      "type": "string"
+    },
+    "Uint64": {
+      "description": "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```",
       "type": "string"
     },
     "WasmMsg": {