Sylvia: Add storey/storage_plus tabs

src/pages/sylvia/basics/contract-structure.mdx

@@ -2,24 +2,87 @@
 tags: ["sylvia"]
 ---
 
+import { Callout, Tabs } from "nextra/components";
+
 # Contract structure
 
 Sylvia contracts are designed using the actor model. An actor is a contract struct that can store a
 state and define a behavior.
 
+<Tabs items={['Storey', 'StoragePlus']}>
+ <Tabs.Tab>
+
+```rust
+use cw_storey::containers::Item;
+
+pub struct CounterContract { pub count: Item<u64>, }
+```
+
+ </Tabs.Tab>
+ <Tabs.Tab>
+
 ```rust
 use sylvia::cw_storage_plus::Item;
 
-pub struct CounterContract {
- pub count: Item<u64>,
-}
+pub struct CounterContract { pub count: Item<u64>, }
 ```
 
+ </Tabs.Tab>
+</Tabs>
+
 In Sylvia we keep the state accessors as part of the contract definition. The accessors are
-[`cw_storage_plus`](../../cw-storage-plus) primitives.
+[`storey`](../../storey) or [`cw_storage_plus`](../../cw-storage-plus) primitives.
 
 Let's take a look at the behavior implementation.
 
+<Tabs items={['Storey', 'StoragePlus']}>
+ <Tabs.Tab>
+
+```rust
+#[cfg_attr(not(feature = "library"), sylvia::entry_points)]
+#[contract]
+impl CounterContract {
+ pub const fn new() -> Self {
+ Self {
+ count: Item::new(0),
+ }
+ }
+
+ #[sv::msg(instantiate)]
+ fn instantiate(&self, ctx: InstantiateCtx) -> StdResult<Response> {
+ self.count
+ .access(&mut CwStorage(ctx.deps.storage))
+ .set(&0)?;
+ Ok(Response::new())
+ }
+
+ #[sv::msg(exec)]
+ fn increment(&self, ctx: ExecCtx) -> StdResult<Response> {
+ let mut storage = CwStorage(ctx.deps.storage);
+ let mut accessor = self.count.access(&mut storage);
+ let count = accessor
+ .get()?
+ .ok_or_else(|| StdError::generic_err("Count not instantiated yet"))?;
+ accessor.set(&(count + 1))?;
+
+ Ok(Response::new())
+ }
+
+ #[sv::msg(query)]
+ fn count(&self, ctx: QueryCtx) -> StdResult<CountResponse> {
+ let count = self
+ .count
+ .access(&CwStorage(ctx.deps.storage))
+ .get()?
+ .ok_or_else(|| StdError::generic_err("Count not instantiated yet"))?;
+ Ok(CountResponse { count })
+ }
+}
+```
+
+ </Tabs.Tab>
+ <Tabs.Tab>
+
 ```rust
 #[cfg_attr(not(feature = "library"), sylvia::entry_points)]
 #[contract]
@@ -53,12 +116,14 @@ impl CounterContract {
 }
 ```
 
+ </Tabs.Tab>
+</Tabs>
+
 In the first two lines, we see the usage of two macros:
 
-- [`entry_points`](https://docs.rs/sylvia/latest/sylvia/attr.entry_points.html) - Generates entry
- points of the contract. By default it will generate `instantiate`, `execute` and `query` entry
- points. The other ones, `migrate`, `reply`, and `sudo`, are generated if a behavior related to
- them is defined in the `impl` block.
+- [`entry_points`](../macros/entry-points) - Generates entry points of the contract. By default it
+ will generate `instantiate`, `execute` and `query` entry points. The other ones, `migrate`,
+ `reply`, and `sudo`, are generated if a behavior related to them is defined in the `impl` block.
 
  This macro is wrapped in `cfg_attr` statement to be compiled only if `library` feature flag is not
  enabled. This way, other users who might want to use this contract in theirs won't get an entry

src/pages/sylvia/basics/interoperability.mdx

@@ -25,7 +25,30 @@ call the
 or
 [`add_messages`](https://docs.rs/cosmwasm-std/latest/cosmwasm_std/struct.Response.html#method.add_messages).
 
-```rust
+<Tabs items={['Storey', 'StoragePlus']}>
+ <Tabs.Tab>
+
+```rust {3, 8, 13}
+#[sv::msg(exec)]
+fn external_increment(&self, ctx: ExecCtx) -> StdResult<Response> {
+ let remote = self
+ .remote
+ .access(&CwStorage(ctx.deps.storage))
+ .get()?
+ .ok_or_else(|| StdError::generic_err("Remote not instantiated"))?;
+ let msg = WasmMsg::Execute {
+ contract_addr: remote.to_string(),
+ msg: to_json_binary(&ExternalExecMsg::Increment {})?,
+ funds: vec![],
+ };
+ Ok(Response::new().add_message(msg))
+}
+```
+
+ </Tabs.Tab>
+ <Tabs.Tab>
+
+```rust {3-4, 9}
 #[sv::msg(exec)]
 fn external_increment(&self, ctx: ExecCtx) -> StdResult<Response> {
  let remote = self.remote.load(ctx.deps.storage)?;
@@ -38,13 +61,75 @@ fn external_increment(&self, ctx: ExecCtx) -> StdResult<Response> {
 }
 ```
 
+ </Tabs.Tab>
+</Tabs>
+
 We can also use the generated
 [`WasmMsg`](https://docs.rs/cosmwasm-std/latest/cosmwasm_std/enum.WasmMsg.html) to construct the
 [`SubMsg`](https://docs.rs/cosmwasm-std/latest/cosmwasm_std/struct.SubMsg.html) and expect reply.
 
 <Callout>Learn more about replies [here](../../core/entrypoints/reply).</Callout>
 
-```rust {1, 24-33, 36-45}
+<Tabs items={['Storey', 'StoragePlus']}>
+ <Tabs.Tab>
+
+```rust {1, 18-20, 26-36, 42-48}
+const SUBMSG_ID: u64 = 1;
+
+pub struct ReplyContract {
+ remote: Item<Remote<'static, Contract>>,
+}
+
+#[entry_points]
+#[contract]
+impl ReplyContract {
+ pub fn new() -> Self {
+ Self {
+ remote: Item::new(0),
+ }
+ }
+
+ #[sv::msg(instantiate)]
+ fn instantiate(&self, ctx: InstantiateCtx, remote_addr: Addr) -> StdResult<Response> {
+ self.remote
+ .access(&mut CwStorage(ctx.deps.storage))
+ .set(&Remote::new(remote_addr))?;
+ Ok(Response::new())
+ }
+
+ #[sv::msg(exec)]
+ fn exec(&self, ctx: ExecCtx) -> StdResult<Response> {
+ let msg = self
+ .remote
+ .access(&mut CwStorage(ctx.deps.storage))
+ .get()?
+ .ok_or_else(|| StdError::generic_err("Remote not instantiated"))?
+ .executor()
+ .contract_exec()?
+ .build();
+
+ let sub_msg = SubMsg::reply_on_success(msg, SUBMSG_ID);
+ let resp = Response::new().add_submessage(sub_msg);
+ Ok(resp)
+ }
+
+ #[sv::msg(reply)]
+ fn reply(&self, ctx: ReplyCtx, reply: Reply) -> StdResult<Response> {
+ match reply.id {
+ SUBMSG_ID => {
+ // Your logic here
+ Ok(Response::new())
+ }
+ _ => Err(StdError::generic_err("Invalid reply id")),
+ }
+ }
+}
+```
+
+ </Tabs.Tab>
+ <Tabs.Tab>
+
+```rust {1, 18-20, 25-34, 39-45}
 const SUBMSG_ID: u64 = 1;
 
 pub struct ReplyContract {
@@ -94,12 +179,36 @@ impl ReplyContract {
 }
 ```
 
+ </Tabs.Tab>
+</Tabs>
+
 Query messages can also be sent through the
 [`query_wasm_smart`](https://docs.rs/cosmwasm-std/latest/cosmwasm_std/struct.QuerierWrapper.html#method.query_wasm_smart)
 method. We can access the
 [`Deps`](https://docs.rs/cosmwasm-std/latest/cosmwasm_std/struct.Deps.html) through the
 [`QueryCtx`](../types/context).
 
+<Tabs items={['Storey', 'StoragePlus']}>
+ <Tabs.Tab>
+
+```rust {5-7}
+#[sv::msg(query)]
+fn external_count(&self, ctx: QueryCtx) -> StdResult<ExternalResponse> {
+ let remote = self
+ .remote
+ .access(&CwStorage(ctx.deps.storage))
+ .get()?
+ .ok_or_else(|| StdError::generic_err("Remote not instantiated"))?;
+
+ ctx.deps
+ .querier
+ .query_wasm_smart(remote, &ExternalQueryMsg::Count {})
+}
+```
+
+ </Tabs.Tab>
+ <Tabs.Tab>
+
 ```rust {5-7}
 #[sv::msg(query)]
 fn external_count(&self, ctx: QueryCtx) -> StdResult<ExternalResponse> {
@@ -111,6 +220,9 @@ fn external_count(&self, ctx: QueryCtx) -> StdResult<ExternalResponse> {
 }
 ```
 
+ </Tabs.Tab>
+</Tabs>
+
 As you see, we can send messages from the Sylvia contract as we would in case of a CosmWasm
 contract. You can check generated messages [here](../macros/generated-types/message-types).