Merge pull request #832 from CosmWasm/init-to-instantiate

Rename entry point init to instantiate

Author: webmaster128

CHANGELOG.md

@@ -67,6 +67,7 @@ and this project adheres to
 
 - contracts: Rename `HandleMsg` to `ExecuteMsg`.
 - all: Rename `handle` entry point to `execute`.
+- all: Rename `init` entry point to `instantiate`.
 - all: Rename `system` entry point to `sudo`.
 - all: Drop support for Rust versions lower than 1.50.0.
 - all: The `query` enpoint is now optional. It is still highly recommended to

MIGRATING.md

@@ -23,6 +23,9 @@ major releases of `cosmwasm`. Note that you can also view the
   # ...
   ```
 
+- Rename the `init` entry point to `instantiate`. Also, rename `InitMsg` to
+  `InstantiateMsg`.
+
 - Rename the `handle` entry point to `execute`. Also, rename `HandleMsg` to
   `ExecuteMsg`.
 

README.md

@@ -101,7 +101,7 @@ The required exports provided by the cosmwasm smart contract are:
 extern "C" fn allocate(size: usize) -> u32;
 extern "C" fn deallocate(pointer: u32);
 
-extern "C" fn init(env_ptr: u32, info_ptr: u32, msg_ptr: u32) -> u32;
+extern "C" fn instantiate(env_ptr: u32, info_ptr: u32, msg_ptr: u32) -> u32;
 extern "C" fn execute(env_ptr: u32, info_ptr: u32, msg_ptr: u32) -> u32;
 extern "C" fn query(env_ptr: u32, msg_ptr: u32) -> u32;
 extern "C" fn migrate(env_ptr: u32, info_ptr: u32, msg_ptr: u32) -> u32;
@@ -110,7 +110,7 @@ extern "C" fn migrate(env_ptr: u32, info_ptr: u32, msg_ptr: u32) -> u32;
 `allocate`/`deallocate` allow the host to manage data within the Wasm VM. If
 you're using Rust, you can implement them by simply
 [re-exporting them from cosmwasm::exports](https://github.com/CosmWasm/cosmwasm/blob/v0.6.3/contracts/hackatom/src/lib.rs#L5).
-`init`, `execute` and `query` must be defined by your contract.
+`instantiate`, `execute` and `query` must be defined by your contract.
 
 ### Imports
 
@@ -194,16 +194,16 @@ pub struct Region {
 If you followed the [instructions above](#Creating), you should have a runable
 smart contract. You may notice that all of the Wasm exports are taken care of by
 `lib.rs`, which should shouldn't need to modify. What you need to do is simply
-look in `contract.rs` and implement `init` and `execute` functions, defining
-your custom `InitMsg` and `ExecuteMsg` structs for parsing your custom message
-types (as json):
+look in `contract.rs` and implement `instantiate` and `execute` functions,
+defining your custom `InstantiateMsg` and `ExecuteMsg` structs for parsing your
+custom message types (as json):
 
 ```rust
-pub fn init<S: Storage, A: Api, Q: Querier>(
+pub fn instantiate<S: Storage, A: Api, Q: Querier>(
     deps: &mut Deps<S, A, Q>,
     env: Env,
     info: MessageInfo,
-    msg: InitMsg,
+    msg: InstantiateMsg,
 ) -> StdResult<Response> {}
 
 pub fn execute<S: Storage, A: Api, Q: Querier>(

contracts/burner/README.md

@@ -3,10 +3,10 @@
 This is a simple contract to demonstrate using migrations to shutdown (or
 "burn") contracts using the migration feature added in CosmWasm 0.9.
 
-This contract cannot be installed directly (via `init`), but is only designed to
-be used for `migrate`. When migrating any existing contract to this burner
-contract, we delete all storage and send all bank tokens to a specified address,
-doing a basic cleanup of the contract.
+This contract cannot be installed directly (via `instantiate`), but is only
+designed to be used for `migrate`. When migrating any existing contract to this
+burner contract, we delete all storage and send all bank tokens to a specified
+address, doing a basic cleanup of the contract.
 
 You can use this contract as-is, or fork it and customize it more if you want to
 do more detailed cleanup.

contracts/burner/examples/schema.rs

@@ -3,7 +3,7 @@ use std::fs::create_dir_all;
 
 use cosmwasm_schema::{export_schema, remove_schemas, schema_for};
 
-use burner::msg::{ExecuteMsg, InitMsg, MigrateMsg};
+use burner::msg::{ExecuteMsg, InstantiateMsg, MigrateMsg};
 
 fn main() {
     let mut out_dir = current_dir().unwrap();
@@ -12,6 +12,6 @@ fn main() {
     remove_schemas(&out_dir).unwrap();
 
     export_schema(&schema_for!(ExecuteMsg), &out_dir);
-    export_schema(&schema_for!(InitMsg), &out_dir);
+    export_schema(&schema_for!(InstantiateMsg), &out_dir);
     export_schema(&schema_for!(MigrateMsg), &out_dir);
 }

contracts/burner/schema/init_msg.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "InstantiateMsg",
+  "description": "A placeholder where we don't take any input",
+  "type": "object"
+}

contracts/burner/schema/instantiate_msg.json

@@ -2,10 +2,15 @@ use cosmwasm_std::{
     attr, entry_point, BankMsg, DepsMut, Env, MessageInfo, Order, Response, StdError, StdResult,
 };
 
-use crate::msg::{ExecuteMsg, InitMsg, MigrateMsg};
+use crate::msg::{ExecuteMsg, InstantiateMsg, MigrateMsg};
 
 #[entry_point]
-pub fn init(_deps: DepsMut, _env: Env, _info: MessageInfo, _msg: InitMsg) -> StdResult<Response> {
+pub fn instantiate(
+    _deps: DepsMut,
+    _env: Env,
+    _info: MessageInfo,
+    _msg: InstantiateMsg,
+) -> StdResult<Response> {
     Err(StdError::generic_err(
         "You can only use this contract for migrations",
     ))
@@ -60,13 +65,13 @@ mod tests {
     use cosmwasm_std::{coins, HumanAddr, StdError, Storage};
 
     #[test]
-    fn init_fails() {
+    fn instantiate_fails() {
         let mut deps = mock_dependencies(&[]);
 
-        let msg = InitMsg {};
+        let msg = InstantiateMsg {};
         let info = mock_info("creator", &coins(1000, "earth"));
         // we can just call .unwrap() to assert this was a success
-        let res = init(deps.as_mut(), mock_env(), info, msg);
+        let res = instantiate(deps.as_mut(), mock_env(), info, msg);
         match res.unwrap_err() {
             StdError::GenericErr { msg, .. } => {
                 assert_eq!(msg, "You can only use this contract for migrations")

contracts/burner/src/contract.rs

@@ -10,9 +10,9 @@ pub struct MigrateMsg {
     pub payout: HumanAddr,
 }
 
-/// InitMsg is a placeholder where we don't take any input
+/// A placeholder where we don't take any input
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
-pub struct InitMsg {}
+pub struct InstantiateMsg {}
 
 /// ExecuteMsg is a placeholder where we don't take any input
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]

contracts/burner/src/msg.rs

@@ -18,9 +18,9 @@
 //! 4. Anywhere you see query(&deps, ...) you must replace it with query(&mut deps, ...)
 
 use cosmwasm_std::{coins, BankMsg, ContractResult, HumanAddr, Order, Response};
-use cosmwasm_vm::testing::{init, migrate, mock_env, mock_info, mock_instance};
+use cosmwasm_vm::testing::{instantiate, migrate, mock_env, mock_info, mock_instance};
 
-use burner::msg::{InitMsg, MigrateMsg};
+use burner::msg::{InstantiateMsg, MigrateMsg};
 use cosmwasm_vm::Storage;
 
 // This line will test the output of cargo wasm
@@ -29,13 +29,13 @@ static WASM: &[u8] = include_bytes!("../target/wasm32-unknown-unknown/release/bu
 // static WASM: &[u8] = include_bytes!("../contract.wasm");
 
 #[test]
-fn init_fails() {
+fn instantiate_fails() {
     let mut deps = mock_instance(WASM, &[]);
 
-    let msg = InitMsg {};
+    let msg = InstantiateMsg {};
     let info = mock_info("creator", &coins(1000, "earth"));
     // we can just call .unwrap() to assert this was a success
-    let res: ContractResult<Response> = init(&mut deps, mock_env(), info, msg);
+    let res: ContractResult<Response> = instantiate(&mut deps, mock_env(), info, msg);
     let msg = res.unwrap_err();
     assert_eq!(
         msg,