Added Entrypoints page.

Author: DariuszDepta

.vitepress/config.mts

@@ -16,6 +16,7 @@ export default withMermaid({
                 items: [
                     {text: 'Introduction', link: '/guide/cosmwasm-core/introduction'},
                     {text: 'Installation', link: '/guide/cosmwasm-core/installation'},
+                    {text: 'Entrypoints', link: '/guide/cosmwasm-core/entrypoints/entrypoints'},
                     {
                         text: 'Architecture',
                         items: [
@@ -33,6 +34,7 @@ export default withMermaid({
                 items: [
                     {text: 'Introduction', link: '/guide/cosmwasm-core/introduction'},
                     {text: 'Installation', link: '/guide/cosmwasm-core/installation'},
+                    {text: 'Entrypoints', link: '/guide/cosmwasm-core/entrypoints/entrypoints'},
                     {
                         text: 'Architecture',
                         collapsed: true,

pages/guide/cosmwasm-core/entrypoints/entrypoints.md

@@ -0,0 +1,130 @@
+# Entrypoints
+
+Entrypoints are where your contract can be called from the outside world. You can equate that to
+your `main` function in C, Rust, Java, etc. However, there is one _small_ difference: in CosmWasm,
+you have multiple of these entrypoints, each one different from the last.
+
+In this section we want to give you a quick overview of all the entrypoints and when they are
+called.
+
+::: tip :bulb: Tip
+In our examples, we will always refer to `StdResult` as the return type (and therefore `StdError` as the error type).
+This is just for convenience since every type that implements the `ToString` type can be used as an error type!
+Meaning, as long as it implements `ToString`, nothing is stopping you from defining `Result<Response, MyError>`.
+This can reduce your code complexity, especially if you want to use the try operator.
+:::
+
+## Defining entrypoints
+
+While you will learn all about entrypoints in the next sections, we want to give you an idea on how
+to define an entrypoint in the first place.
+
+CosmWasm defines the handy `#[entry_point]` attribute macro. You simply annotate a function with it,
+and it automatically generates code that communicates to the VM: "Hey! This is an entrypoint, please
+use it when needed!"
+
+::: tip :bulb: Tip
+When defining an entrypoint, it is important to use the correct types for the parameters and
+return type. Incorrect types will cause errors when trying to call the contract.
+
+In the following sections we will take a look at all possible entrypoints, including the
+correct function signature.
+:::
+
+::: tip :bulb: Tip
+Even though the sections will show you to use `#[entry_point]`, it is recommended to define your
+endpoints as `#[cfg_attr(not(feature = "library"), entry_point)]`.
+
+The reason behind that is that it allows you to reuse your contract as a library.
+:::
+
+```Rust
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn instantiate(
+    deps: DepsMut,
+    env: Env,
+    info: MessageInfo,
+    msg: InstantiateMsg,
+) -> StdResult<Response> {
+    // Do some logic here
+    Ok(Response::default())
+}
+```
+
+## Entrypoint parameters
+
+Entrypoints have a few parameters (as you can see above), some of them are predefined by
+`cosmwasm-std`, others are defined by the user themselves.
+
+Here we go over the different predefined types the standard library provides, and how you can define
+your own types.
+
+### Predefined types
+
+#### `Deps`/`DepsMut`
+
+These structs provide you access to the:
+
+- Storage
+- VM API
+- Querier
+
+The big difference is that `DepsMut` gives you _mutable_ access to the storage. This design is
+deliberate since you, for example, can't mutate the state in the `query` endpoint. Instead of
+relying on runtime errors, this is made _irrepresentable_ through Rust's type system.
+
+#### `Env`
+
+This struct provides you with some information of the current state of the environment your contract
+is executed in.
+
+The information provided is, for example, the block height, chain ID, transaction info, etc.
+Basically anything you'd ever want to know about the current state of the execution environment!
+
+#### `MessageInfo`
+
+This struct isn't provided to every endpoint, only to a select few.
+
+It provides you with some information that might be crucial to you, depending on the operation you
+want to perform. It contains the sender of the message you just received, and the funds that were
+transferred along with it to your contract.
+
+### Defining your own messages
+
+In our examples, you might have seen messages such as `InstantiateMsg`. These messages are actually
+_user-defined_, meaning each contract developer has to define them themselves.
+
+To make this easier our `cosmwasm-schema` crate provides the `cw_serde` attribute macro, to define
+an instantiate message, you simply write this:
+
+::: code-group
+```Rust [instantiate.rs]
+#[cw_serde]
+struct CustomInstantiateMsg {
+  initial_admins: Vec<Addr>,
+}
+```
+:::
+
+::: tip :bulb: Tip
+This macro actually just expands into a bunch of `derive` attributes.
+We provide this simply for your convenience, otherwise you'd have to keep track of all of these derives yourself.
+
+::: details Without `#[cw_serde]`
+
+::: code-group
+```Rust [instantiate.rs]
+#[derive(
+  serde::Serialize,
+  serde::Deserialize,
+  Clone,
+  Debug,
+  PartialEq,
+  schemars::JsonSchema
+)]
+struct CustomInstantiateMsg {
+  initial_admins: Vec<Addr>,
+}
+```
+  
+:::