Add sg-std and sg-multi-test from Launchpad

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members  = ["contracts/fair-burn", "test/*"]
+members  = ["packages/*", "contracts/fair-burn", "test/*"]
 resolver = "2"
 
 [workspace.package]
@@ -26,8 +26,8 @@ semver             = "1.0.16"
 serde              = { version = "1.0.145", default-features = false, features = ["derive"] }
 thiserror          = "1.0.31"
 anyhow             = "1.0.41"
-sg-std             = { version = "2.3.0" }
-sg-multi-test      = { version = "2.3.0" }
+sg-std             = { version = "3.1.0", path = "packages/sg-std" }
+sg-multi-test      = { version = "3.1.0", path = "packages/sg-multi-test" }
 
 # dev-dependencies
 cw-multi-test  = "0.16.5"

README.md

@@ -1 +1,8 @@
-# Stargaze Core Contracts
+# Stargaze Core Libraries
+
+This repository contains the core contracts and libraries that are shared among all Stargaze protocols.
+
+| Package                                                     | Description                                                                                      |
+|-------------------------------------------------------------|--------------------------------------------------------------------------------------------------|
+| [Stargaze Fair Burn](./contracts//fair-burn/README.md)      | Contract for fees and Developer Royalties.                                                       |
+| [Stargaze Standard Library](./packages/sg-std/README.md)    | Common Stargaze libraries for interfacing with CosmWasm smart contracts.                         |

justfile

@@ -46,3 +46,7 @@ e2e-test-arm: deploy-local-arm
 # e2e-test-full: dl-artifacts optimize e2e-test
 
 # e2e-test-full-arm: dl-artifacts optimize-arm e2e-test-arm
+
+publish:
+	cd packages/sg-std && cargo publish && cd ../..
+	cd packages/sg-multi-test && cargo publish && cd ../..

packages/sg-multi-test/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name        = "sg-multi-test"
+authors     = ["Jorge Hernandez <[email protected]>"]
+description = "Integration test helpers for Stargaze custom contracts"
+version     = "3.1.0"
+edition     = { workspace = true }
+homepage    = { workspace = true }
+repository  = { workspace = true }
+license     = { workspace = true }
+
+[dependencies]
+anyhow        = "1"
+cosmwasm-std  = { workspace = true }
+cw-multi-test = { workspace = true }
+schemars      = { workspace = true }
+serde         = { workspace = true }
+sg-std        = { workspace = true }

packages/sg-multi-test/src/lib.rs

@@ -0,0 +1,3 @@
+mod multi;
+
+pub use crate::multi::{mock_deps, StargazeApp, StargazeDeps, StargazeModule};

packages/sg-multi-test/src/multi.rs

@@ -0,0 +1,147 @@
+use anyhow::{bail, Result as AnyResult};
+use cosmwasm_std::testing::{MockApi, MockQuerier, MockStorage};
+use cosmwasm_std::{
+    Addr, Api, Binary, BlockInfo, CustomQuery, Empty, Querier, QuerierResult, Storage,
+};
+use cosmwasm_std::{BankMsg, OwnedDeps};
+use cw_multi_test::{
+    App, AppResponse, BankKeeper, BasicAppBuilder, CosmosRouter, Module, WasmKeeper,
+};
+use schemars::JsonSchema;
+use serde::de::DeserializeOwned;
+use sg_std::{StargazeMsgWrapper, StargazeQuery};
+use std::fmt::Debug;
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+
+pub struct StargazeModule {}
+
+pub type StargazeDeps = OwnedDeps<MockStorage, MockApi, MockQuerier, StargazeQuery>;
+
+pub fn mock_deps() -> StargazeDeps {
+    OwnedDeps {
+        storage: MockStorage::default(),
+        api: MockApi::default(),
+        querier: MockQuerier::default(),
+        custom_query_type: PhantomData,
+    }
+}
+
+impl StargazeModule {}
+
+impl Module for StargazeModule {
+    type ExecT = StargazeMsgWrapper;
+    type QueryT = Empty;
+    type SudoT = Empty;
+
+    fn execute<ExecC, QueryC>(
+        &self,
+        api: &dyn Api,
+        storage: &mut dyn Storage,
+        router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
+        block: &BlockInfo,
+        sender: Addr,
+        msg: StargazeMsgWrapper,
+    ) -> AnyResult<AppResponse>
+    where
+        ExecC: Debug + Clone + PartialEq + JsonSchema + DeserializeOwned + 'static,
+        QueryC: CustomQuery + DeserializeOwned + 'static,
+    {
+        let StargazeMsgWrapper {
+            route: _,
+            msg_data,
+            version: _,
+        } = msg;
+
+        match msg_data {
+            sg_std::StargazeMsg::FundCommunityPool { amount } => {
+                let msg = BankMsg::Send {
+                    to_address: "community_pool".to_owned(),
+                    amount,
+                }
+                .into();
+                router.execute(api, storage, block, sender, msg)?;
+                Ok(AppResponse::default())
+            }
+            sg_std::StargazeMsg::FundFairburnPool { amount } => {
+                let msg = BankMsg::Send {
+                    to_address: "fairburn_pool".to_owned(),
+                    amount,
+                }
+                .into();
+                router.execute(api, storage, block, sender, msg)?;
+                Ok(AppResponse::default())
+            }
+            sg_std::StargazeMsg::ClaimFor {
+                action: _,
+                address: _,
+            } => Ok(AppResponse::default()),
+        }
+    }
+    fn sudo<ExecC, QueryC>(
+        &self,
+        _api: &dyn Api,
+        _storage: &mut dyn Storage,
+        _router: &dyn CosmosRouter<ExecC = ExecC, QueryC = QueryC>,
+        _block: &BlockInfo,
+        _msg: Self::SudoT,
+    ) -> AnyResult<AppResponse>
+    where
+        ExecC: Debug + Clone + PartialEq + JsonSchema + DeserializeOwned + 'static,
+        QueryC: CustomQuery + DeserializeOwned + 'static,
+    {
+        bail!("sudo not implemented")
+    }
+
+    fn query(
+        &self,
+        _api: &dyn Api,
+        _storage: &dyn Storage,
+        _querier: &dyn Querier,
+        _block: &BlockInfo,
+        request: Empty,
+    ) -> anyhow::Result<Binary> {
+        bail!("custom query not implemented {:?}", request)
+    }
+}
+
+pub type StargazeBasicApp =
+    App<BankKeeper, MockApi, MockStorage, StargazeModule, WasmKeeper<StargazeMsgWrapper, Empty>>;
+
+pub struct StargazeApp(StargazeBasicApp);
+
+impl Deref for StargazeApp {
+    type Target = StargazeBasicApp;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for StargazeApp {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl Querier for StargazeApp {
+    fn raw_query(&self, bin_request: &[u8]) -> QuerierResult {
+        self.0.raw_query(bin_request)
+    }
+}
+
+impl StargazeApp {
+    pub fn new() -> Self {
+        Self(
+            BasicAppBuilder::<StargazeMsgWrapper, Empty>::new_custom()
+                .with_custom(StargazeModule {})
+                .build(|_, _, _| {}),
+        )
+    }
+}
+
+impl Default for StargazeApp {
+    fn default() -> Self {
+        Self::new()
+    }
+}

packages/sg-std/.cargo/config

@@ -0,0 +1,4 @@
+[alias]
+wasm = "build --release --target wasm32-unknown-unknown"
+unit-test = "test --lib"
+schema = "run --example schema"

packages/sg-std/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name        = "sg-std"
+authors     = ["Jorge Hernandez <[email protected]>"]
+description = "Bindings for CosmWasm contracts to call into custom modules of Stargaze"
+version     = "3.1.0"
+edition     = { workspace = true }
+homepage    = { workspace = true }
+repository  = { workspace = true }
+license     = { workspace = true }
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+# for more explicit tests, cargo test --features=backtraces
+backtraces = ["cosmwasm-std/backtraces"]
+# use library feature to disable all instantiate/execute/query exports
+library = []
+
+[dependencies]
+cosmwasm-schema = { workspace = true }
+cosmwasm-std    = { workspace = true }
+cw721           = { workspace = true }
+cw-utils        = { workspace = true }
+schemars        = { workspace = true }
+serde           = { workspace = true }
+thiserror       = { workspace = true }