Add #[entry_point] macro attribute to generate entry points

CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 0.13.1 (unreleased)
+
+**cosmwasm-std**
+
+- Add the new `#[entry_point]` macro attribute that serves as an alternative
+  implementation to `cosmwasm_std::create_entry_points!(contract)` and
+  `cosmwasm_std::create_entry_points_with_migration!(contract)`. Both ways are
+  supported in the 0.13 series.
+
 ## 0.13.0 (2020-01-06)
 
 **all**

MIGRATING.md

@@ -4,6 +4,79 @@ This guide explains what is needed to upgrade contracts when migrating over
 major releases of `cosmwasm`. Note that you can also view the
 [complete CHANGELOG](./CHANGELOG.md) to understand the differences.
 
+## 0.13 -> 0.14 (unreleased)
+
+- Update CosmWasm dependencies in Cargo.toml (skip the ones you don't use):
+
+  ```
+  [dependencies]
+  cosmwasm-std = "0.14.0"
+  cosmwasm-storage = "0.14.0"
+  # ...
+
+  [dev-dependencies]
+  cosmwasm-schema = "0.14.0"
+  cosmwasm-vm = "0.14.0"
+  # ...
+  ```
+
+- Use the new entry point system. From `lib.rs` remove
+
+  ```rust
+  #[cfg(target_arch = "wasm32")]
+  cosmwasm_std::create_entry_points!(contract);
+
+  // or
+
+  #[cfg(target_arch = "wasm32")]
+  cosmwasm_std::create_entry_points_with_migration!(contract);
+  ```
+
+  Then add the macro attribute `#[entry_point]` to your `contract.rs` as
+  follows:
+
+  ```rust
+  use cosmwasm_std::{entry_point, … };
+
+  // …
+
+  #[entry_point]
+  pub fn init(
+      _deps: DepsMut,
+      _env: Env,
+      _info: MessageInfo,
+      _msg: InitMsg,
+  ) -> StdResult<InitResponse> {
+      // …
+  }
+
+  #[entry_point]
+  pub fn handle(
+      _deps: DepsMut,
+      _env: Env,
+      _info: MessageInfo,
+      _msg: HandleMsg,
+  ) -> StdResult<HandleResponse> {
+      // …
+  }
+
+  // only if you have migrate
+  #[entry_point]
+  pub fn migrate(
+      deps: DepsMut,
+      env: Env,
+      _info: MessageInfo,
+      msg: MigrateMsg,
+  ) -> StdResult<MigrateResponse> {
+      // …
+  }
+
+  #[entry_point]
+  pub fn query(_deps: Deps, _env: Env, _msg: QueryMsg) -> StdResult<QueryResponse> {
+      // …
+  }
+  ```
+
 ## 0.12 -> 0.13
 
 - The minimum Rust supported version for 0.13 is 1.47.0.

contracts/README.md

@@ -41,3 +41,23 @@ docker run --rm -v "$(pwd)":/code \
   --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \
   cosmwasm/rust-optimizer:0.10.5 ./contracts/staking
 ```
+
+## Entry points
+
+The development contracts in this folder contain a variety of different entry
+points in order to demonstrate and test the flexibility we have.
+
+| Contract | Macro                                         | Has `query` | Has `migrate` |
+| -------- | --------------------------------------------- | ----------- | ------------- |
+| burner   | `#[entry_point]`                              | yes         | yes           |
+| hackatom | [`create_entry_points_with_migration!`][cepm] | yes         | yes           |
+| queue    | mixed<sup>1</sup>                             | yes         | yes           |
+| reflect  | [`create_entry_points!`][cep]                 | yes         | no            |
+| staking  | `#[entry_point]`                              | yes         | no            |
+
+<sup>1</sup> Because we can. Don't try this at home.
+
+[cepm]:
+  https://docs.rs/cosmwasm-std/0.13.0/cosmwasm_std/macro.create_entry_points_with_migration.html
+[cep]:
+  https://docs.rs/cosmwasm-std/0.13.0/cosmwasm_std/macro.create_entry_points.html

contracts/burner/src/contract.rs

@@ -1,10 +1,11 @@
 use cosmwasm_std::{
-    attr, BankMsg, Deps, DepsMut, Env, HandleResponse, InitResponse, MessageInfo, MigrateResponse,
-    Order, QueryResponse, StdError, StdResult,
+    attr, entry_point, BankMsg, Deps, DepsMut, Env, HandleResponse, InitResponse, MessageInfo,
+    MigrateResponse, Order, QueryResponse, StdError, StdResult,
 };
 
 use crate::msg::{HandleMsg, InitMsg, MigrateMsg, QueryMsg};
 
+#[entry_point]
 pub fn init(
     _deps: DepsMut,
     _env: Env,
@@ -16,6 +17,7 @@ pub fn init(
     ))
 }
 
+#[entry_point]
 pub fn handle(
     _deps: DepsMut,
     _env: Env,
@@ -27,6 +29,7 @@ pub fn handle(
     ))
 }
 
+#[entry_point]
 pub fn migrate(
     deps: DepsMut,
     env: Env,
@@ -61,6 +64,7 @@ pub fn migrate(
     })
 }
 
+#[entry_point]
 pub fn query(_deps: Deps, _env: Env, _msg: QueryMsg) -> StdResult<QueryResponse> {
     Err(StdError::generic_err(
         "You can only use this contract for migrations",

contracts/burner/src/lib.rs

@@ -1,5 +1,2 @@
 pub mod contract;
 pub mod msg;
-
-#[cfg(target_arch = "wasm32")]
-cosmwasm_std::create_entry_points_with_migration!(contract);

contracts/queue/Cargo.toml

@@ -28,6 +28,8 @@ default = ["cranelift"]
 cranelift = ["cosmwasm-vm/cranelift"]
 # For quicker tests, cargo test --lib. for more explicit tests, cargo test --features=backtraces
 backtraces = ["cosmwasm-std/backtraces", "cosmwasm-vm/backtraces"]
+# this is to demonstrate conditional entry-points for cosmwasm-plus style
+library = []
 
 [dependencies]
 cosmwasm-std = { path = "../../packages/std", features = ["iterator"] }

contracts/queue/examples/schema.rs

@@ -3,9 +3,8 @@ use std::fs::create_dir_all;
 
 use cosmwasm_schema::{export_schema, remove_schemas, schema_for};
 
-use queue::contract::{
-    CountResponse, HandleMsg, InitMsg, Item, ListResponse, QueryMsg, SumResponse,
-};
+use queue::contract::{CountResponse, HandleMsg, Item, ListResponse, QueryMsg, SumResponse};
+use queue::msg::{InitMsg, MigrateMsg};
 
 fn main() {
     let mut out_dir = current_dir().unwrap();
@@ -15,6 +14,7 @@ fn main() {
 
     export_schema(&schema_for!(InitMsg), &out_dir);
     export_schema(&schema_for!(HandleMsg), &out_dir);
+    export_schema(&schema_for!(MigrateMsg), &out_dir);
     export_schema(&schema_for!(QueryMsg), &out_dir);
     export_schema(&schema_for!(Item), &out_dir);
     export_schema(&schema_for!(CountResponse), &out_dir);

contracts/queue/schema/migrate_msg.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "MigrateMsg",
+  "type": "object"
+}

contracts/queue/src/contract.rs

@@ -4,12 +4,11 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use cosmwasm_std::{
-    from_slice, to_binary, to_vec, Binary, Deps, DepsMut, Env, HandleResponse, InitResponse,
-    MessageInfo, Order, QueryResponse, StdResult,
+    entry_point, from_slice, to_binary, to_vec, Binary, Deps, DepsMut, Env, HandleResponse,
+    InitResponse, MessageInfo, MigrateResponse, Order, QueryResponse, StdResult, Storage,
 };
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
-pub struct InitMsg {}
+use crate::msg::{InitMsg, MigrateMsg};
 
 // we store one entry for each item in the queue
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
@@ -82,16 +81,21 @@ pub fn handle(
     msg: HandleMsg,
 ) -> StdResult<HandleResponse> {
     match msg {
-        HandleMsg::Enqueue { value } => enqueue(deps, value),
-        HandleMsg::Dequeue {} => dequeue(deps),
+        HandleMsg::Enqueue { value } => handle_enqueue(deps, value),
+        HandleMsg::Dequeue {} => handle_dequeue(deps),
     }
 }
 
 const FIRST_KEY: u8 = 0;
 
-fn enqueue(deps: DepsMut, value: i32) -> StdResult<HandleResponse> {
+fn handle_enqueue(deps: DepsMut, value: i32) -> StdResult<HandleResponse> {
+    enqueue(deps.storage, value)?;
+    Ok(HandleResponse::default())
+}
+
+fn enqueue(storage: &mut dyn Storage, value: i32) -> StdResult<()> {
     // find the last element in the queue and extract key
-    let last_item = deps.storage.range(None, None, Order::Descending).next();
+    let last_item = storage.range(None, None, Order::Descending).next();
 
     let new_key = match last_item {
         None => FIRST_KEY,
@@ -101,11 +105,11 @@ fn enqueue(deps: DepsMut, value: i32) -> StdResult<HandleResponse> {
     };
     let new_value = to_vec(&Item { value })?;
 
-    deps.storage.set(&[new_key], &new_value);
-    Ok(HandleResponse::default())
+    storage.set(&[new_key], &new_value);
+    Ok(())
 }
 
-fn dequeue(deps: DepsMut) -> StdResult<HandleResponse> {
+fn handle_dequeue(deps: DepsMut) -> StdResult<HandleResponse> {
     // find the first element in the queue and extract value
     let first = deps.storage.range(None, None, Order::Ascending).next();
 
@@ -120,6 +124,30 @@ fn dequeue(deps: DepsMut) -> StdResult<HandleResponse> {
     }
 }
 
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn migrate(
+    deps: DepsMut,
+    _env: Env,
+    _info: MessageInfo,
+    _msg: MigrateMsg,
+) -> StdResult<MigrateResponse> {
+    // clear all
+    let keys: Vec<_> = deps
+        .storage
+        .range(None, None, Order::Ascending)
+        .map(|(key, _)| key)
+        .collect();
+    for key in keys {
+        deps.storage.remove(&key);
+    }
+
+    // Write new values
+    enqueue(deps.storage, 100)?;
+    enqueue(deps.storage, 101)?;
+    enqueue(deps.storage, 102)?;
+    Ok(MigrateResponse::default())
+}
+
 pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<QueryResponse> {
     match msg {
         QueryMsg::Count {} => to_binary(&query_count(deps)?),

contracts/queue/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod contract;
+pub mod msg;
 
 #[cfg(target_arch = "wasm32")]
 cosmwasm_std::create_entry_points!(contract);

contracts/queue/src/msg.rs

@@ -0,0 +1,10 @@
+#![allow(clippy::field_reassign_with_default)] // see https://github.com/CosmWasm/cosmwasm/issues/685
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+pub struct InitMsg {}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+pub struct MigrateMsg {}