From 9d50d688a2504a317cc82b2010289ec941b6c97b Mon Sep 17 00:00:00 2001 From: jbernal87 Date: Wed, 24 Apr 2024 15:07:48 +0200 Subject: [PATCH 01/19] initial contract startgate example --- .../Cargo.toml | 55 ++ .../src/contract.rs | 46 + .../src/error.rs | 14 + .../src/handle.rs | 1 + .../src/lib.rs | 13 + .../src/msg.rs | 34 + .../src/order_management.rs | 70 ++ .../src/query.rs | 31 + .../src/state.rs | 11 + .../src/testing/mod.rs | 1 + .../src/testing/test_bank.rs | 84 ++ .../src/types.rs | 170 ++++ .../src/utils.rs | 833 ++++++++++++++++++ 13 files changed, 1363 insertions(+) create mode 100644 contracts/injective-cosmwasm-stargate-example/Cargo.toml create mode 100644 contracts/injective-cosmwasm-stargate-example/src/contract.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/error.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/handle.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/lib.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/msg.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/order_management.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/query.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/state.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/types.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/utils.rs diff --git a/contracts/injective-cosmwasm-stargate-example/Cargo.toml b/contracts/injective-cosmwasm-stargate-example/Cargo.toml new file mode 100644 index 00000000..90fb7b76 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/Cargo.toml @@ -0,0 +1,55 @@ +[package] +authors = [ "Markus Waas " ] +edition = "2018" +name = "injective-cosmwasm-stargate-example" +version = "0.0.1" + +exclude = [ + # Those files are rust-optimizer artifacts. You might want to commit them for convenience but they should not be part of the source code publication. + "contract.wasm", + "hash.txt", +] + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[lib] +crate-type = [ "cdylib", "rlib" ] + +[features] +# for more explicit tests, cargo test --features=backtraces +backtraces = [ "cosmwasm-std/backtraces" ] +# use library feature to disable all instantiate/execute/query exports +library = [ ] +integration = [ ] + +[package.metadata.scripts] +optimize = """docker run --rm -v "$(pwd)":/code \ + --mount type=volume,source="$(basename "$(pwd)")_cache",target=/code/target \ + --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \ + cosmwasm/workspace-optimizer-arm64:0.12.11 +""" + +[dependencies] +cosmwasm-std = { version = "1.5.0", features = [ "abort", "cosmwasm_1_2", "cosmwasm_1_3", "cosmwasm_1_4", "iterator", "stargate" ] } +cw-storage-plus = { version = "1.2.0" } +cw2 = { version = "0.16.0" } +injective-cosmwasm = { path = "../../packages/injective-cosmwasm" } +injective-math = { path = "../../packages/injective-math" } +injective-protobuf = { path = "../../packages/injective-protobuf"} +schemars = { version ="0.8.16"} +serde = { version = "1.0.196", default-features = false, features = [ "derive" ] } +thiserror = { version = "1.0.56" } +protobuf = { version = "3.3.0" } +prost = { version = "0.12.3" } +injective-std = { path = "../../packages/injective-std" } +cosmos-sdk-proto = { version = "0.20.0", default-features = false } +cosmwasm-schema = { version = "1.5.0" } +base64 = "0.21.5" +serde_json = "1.0.111" + + + +[dev-dependencies] +injective-test-tube = { path = "/home/jose/RustroverProjects/test-tube/packages/injective-test-tube" } +injective-std = { path = "../../packages/injective-std" } +injective-testing = { version = "0.1.6" } diff --git a/contracts/injective-cosmwasm-stargate-example/src/contract.rs b/contracts/injective-cosmwasm-stargate-example/src/contract.rs new file mode 100644 index 00000000..ca303fd5 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/contract.rs @@ -0,0 +1,46 @@ +use crate::{ + error::ContractError, + msg::{ExecuteMsg, InstantiateMsg, QueryMsg}, + query::{ + handle_query_stargate, + }, +}; +use cosmwasm_std::{entry_point, Binary, Deps, DepsMut, Env, MessageInfo, Reply, Response, StdResult}; +use cw2::set_contract_version; +use injective_cosmwasm::{create_deposit_msg, InjectiveMsgWrapper, InjectiveQuerier, InjectiveQueryWrapper}; + +const CONTRACT_NAME: &str = "crates.io:injective:dummy"; +const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION"); +pub const CREATE_SPOT_ORDER_REPLY_ID: u64 = 0u64; +pub const CREATE_DERIVATIVE_ORDER_REPLY_ID: u64 = 1u64; +pub const MSG_EXEC: &str = "/cosmos.authz.v1beta1.MsgExec"; + +#[cfg_attr(not(feature = "library"), entry_point)] +pub fn instantiate(deps: DepsMut, _env: Env, _info: MessageInfo, _msg: InstantiateMsg) -> Result { + set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?; + Ok(Response::default()) +} + +#[cfg_attr(not(feature = "library"), entry_point)] +pub fn execute( + deps: DepsMut, + env: Env, + info: MessageInfo, + msg: ExecuteMsg, +) -> Result, ContractError> { + match msg { + ExecuteMsg::TestDepositMsg { subaccount_id, amount } => { + Ok(Response::new().add_message(create_deposit_msg(env.contract.address, subaccount_id, amount))) + } + } +} + +#[cfg_attr(not(feature = "library"), entry_point)] +pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult { + let querier = InjectiveQuerier::new(&deps.querier); + match msg { + QueryMsg::QueryStargate { path, query_request } => handle_query_stargate(&deps.querier, path, query_request), + } +} + + diff --git a/contracts/injective-cosmwasm-stargate-example/src/error.rs b/contracts/injective-cosmwasm-stargate-example/src/error.rs new file mode 100644 index 00000000..54dea889 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/error.rs @@ -0,0 +1,14 @@ +use cosmwasm_std::StdError; +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum ContractError { + #[error("{0}")] + Std(#[from] StdError), + #[error("Unrecognized reply id: {0}")] + UnrecognizedReply(u64), + #[error("Invalid reply from sub-message {id}, {err}")] + ReplyParseFailure { id: u64, err: String }, + #[error("Failure response from submsg: {0}")] + SubMsgFailure(String), +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/handle.rs b/contracts/injective-cosmwasm-stargate-example/src/handle.rs new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/handle.rs @@ -0,0 +1 @@ + diff --git a/contracts/injective-cosmwasm-stargate-example/src/lib.rs b/contracts/injective-cosmwasm-stargate-example/src/lib.rs new file mode 100644 index 00000000..7f92cfb1 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/lib.rs @@ -0,0 +1,13 @@ +pub mod contract; +mod error; +mod handle; +pub mod msg; +mod order_management; +mod query; +mod state; +#[cfg(test)] +mod testing; +mod types; +#[cfg(test)] +pub mod utils; +pub use crate::error::ContractError; diff --git a/contracts/injective-cosmwasm-stargate-example/src/msg.rs b/contracts/injective-cosmwasm-stargate-example/src/msg.rs new file mode 100644 index 00000000..04d62f34 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/msg.rs @@ -0,0 +1,34 @@ +use cosmwasm_std::Coin; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + +use injective_cosmwasm::{CancellationStrategy, MarketId, OracleInfo, OracleType, OrderSide, SubaccountId}; + +pub const MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT: &str = "/injective.exchange.v1beta1.MsgCreateSpotLimitOrder"; +pub const MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT: &str = "/injective.exchange.v1beta1.MsgCreateDerivativeLimitOrder"; + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct InstantiateMsg {} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum ExecuteMsg { + TestDepositMsg { + subaccount_id: SubaccountId, + amount: Coin, + }, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum QueryMsg { + QueryStargate { + path: String, + query_request: String, + }, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct QueryStargateResponse { + pub value: String, +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/order_management.rs b/contracts/injective-cosmwasm-stargate-example/src/order_management.rs new file mode 100644 index 00000000..158f5bd5 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/order_management.rs @@ -0,0 +1,70 @@ +use crate::types; +use cosmwasm_std::{CosmosMsg, StdResult}; +use injective_cosmwasm::{FullDerivativeMarket, InjectiveMsgWrapper, OrderType, SpotMarket}; +use injective_math::FPDecimal; +use prost::Message; + +pub fn create_stargate_msg(type_url: &str, value: Vec) -> StdResult> { + Ok(CosmosMsg::Stargate { + type_url: type_url.to_string(), + value: value.into(), + }) +} + +pub fn create_spot_limit_order( + price: FPDecimal, + quantity: FPDecimal, + order_type: OrderType, + sender: &str, + subaccount_id: &str, + market: &SpotMarket, +) -> types::MsgCreateSpotLimitOrder { + types::MsgCreateSpotLimitOrder { + sender: sender.to_string(), + order: Some(types::SpotOrder { + market_id: market.market_id.as_str().into(), + order_info: Some(types::OrderInfo { + subaccount_id: subaccount_id.to_string(), + fee_recipient: sender.to_string(), + price: price.to_string(), + quantity: quantity.to_string(), + }), + order_type: order_type as i32, + trigger_price: "".to_string(), + }), + } +} + +pub fn create_derivative_limit_order( + price: FPDecimal, + quantity: FPDecimal, + margin: FPDecimal, + order_type: OrderType, + sender: &str, + subaccount_id: &str, + market: &FullDerivativeMarket, +) -> types::MsgCreateDerivativeLimitOrder { + let market_id = market.market.as_ref().unwrap().market_id.as_str().to_string(); + + types::MsgCreateDerivativeLimitOrder { + sender: sender.to_string(), + order: Some(types::DerivativeOrder { + market_id, + order_info: Some(types::OrderInfo { + subaccount_id: subaccount_id.to_string(), + fee_recipient: sender.to_string(), + price: price.to_string(), + quantity: quantity.to_string(), + }), + order_type: order_type as i32, + margin: margin.to_string(), + trigger_price: "".to_string(), + }), + } +} + +pub(crate) fn encode_bytes_message(order_msg: &T) -> Result, prost::EncodeError> { + let mut buffer = Vec::new(); + order_msg.encode(&mut buffer)?; // Encode the message using prost + Ok(buffer) +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/query.rs b/contracts/injective-cosmwasm-stargate-example/src/query.rs new file mode 100644 index 00000000..3feb67b1 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/query.rs @@ -0,0 +1,31 @@ +use cosmwasm_std::{to_json_binary, Binary, to_json_vec, ContractResult, StdError, StdResult, SystemResult, QuerierWrapper}; +use injective_cosmwasm::{InjectiveQueryWrapper}; +use crate::msg::QueryStargateResponse; +use base64::engine::general_purpose::STANDARD as BASE64_STANDARD; +use base64::Engine as _; + +pub fn handle_query_stargate(querier: &QuerierWrapper, path: String, query_request: String) -> StdResult { + + let data = Binary::from_base64(&query_request)?; + let request = &cosmwasm_std::QueryRequest::::Stargate { path, data }; + + let raw = to_json_vec(request).map_err(|serialize_err| { + StdError::generic_err(format!("Serializing QueryRequest: {}", serialize_err)) + })?; + + let value = match querier.raw_query (&raw) { + SystemResult::Err(system_err) => Err(StdError::generic_err(format!( + "Querier system error: {}", + system_err + ))), + SystemResult::Ok(ContractResult::Err(contract_err)) => Err(StdError::generic_err(format!( + "Querier contract error: {}", + contract_err + ))), + SystemResult::Ok(ContractResult::Ok(value)) => Ok(value), + }?; + + + to_json_binary(&QueryStargateResponse { value: String::from(decoded_value)? }) +} + diff --git a/contracts/injective-cosmwasm-stargate-example/src/state.rs b/contracts/injective-cosmwasm-stargate-example/src/state.rs new file mode 100644 index 00000000..4f4d8280 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/state.rs @@ -0,0 +1,11 @@ +use cosmwasm_schema::cw_serde; +use cw_storage_plus::Item; +use injective_cosmwasm::{MarketId, SubaccountId}; + +pub const ORDER_CALL_CACHE: Item> = Item::new("order_call_cache"); + +#[cw_serde] +pub struct CacheOrderInfo { + pub subaccount: SubaccountId, + pub market_id: MarketId, +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs new file mode 100644 index 00000000..73ddca58 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs @@ -0,0 +1 @@ +mod test_bank; diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs new file mode 100644 index 00000000..a3a86801 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs @@ -0,0 +1,84 @@ +use cosmwasm_std::{Addr, from_json, Coin}; +use injective_test_tube::{Account, Module, Wasm}; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use injective_cosmwasm::{checked_address_to_subaccount_id}; + +use crate::{ + msg::QueryMsg, + utils::{ + ExchangeType, Setup, + }, +}; +use crate::msg::QueryStargateResponse; +use serde_json::{Value, Map}; +use crate::utils::{BASE_DECIMALS, BASE_DENOM, str_coin}; + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_msg_deposit() { + let env = Setup::new(ExchangeType::None); + + let wasm = Wasm::new(&env.app); + let user = &env.users[0]; + + let subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(user.account.address()), 1u32); + // Execute contract + + let query_msg = QueryMsg::QueryStargate { + path: "/cosmos.auth.v1beta1.Query/Params".to_string(), + query_request: "".to_string(), + }; + + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + let contract_response = contract_response.value; + let response: ParamResponse = serde_json::from_str(&contract_response).unwrap(); + assert_eq!(response.params.max_memo_characters, "256"); + // let response: Value = serde_json::from_str(&contract_response).unwrap(); + // let response = response.as_object().unwrap(); + // println!("{:?}", response); + // assert_eq!(response.get("params").unwrap().as_object().unwrap().get("max_memo_characters").unwrap().as_str().unwrap(), "256"); +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct ParamResponse { + pub params: T, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct AuthParams { + pub max_memo_characters: String, + pub sig_verify_cost_ed25519: String, +} + + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_exchange_param() { + let env = Setup::new(ExchangeType::None); + + let wasm = Wasm::new(&env.app); + let user = &env.users[0]; + + let subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(user.account.address()), 1u32); + // Execute contract + + let query_msg = QueryMsg::QueryStargate { + path: "/injective.exchange.v1beta1.Query/QueryExchangeParams".to_string(), + query_request: "".to_string(), + }; + + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + let contract_response = contract_response.value; + println!("{:?}", contract_response); + let response: ParamResponse = from_json(&contract_response).unwrap(); + println!("{:?}", response); + let listing_fee_coin = str_coin("1000", BASE_DENOM, BASE_DECIMALS); + assert_eq!(response.params.spot_market_instant_listing_fee, listing_fee_coin); + assert_eq!(1,2) +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct ExchangeParams { + pub spot_market_instant_listing_fee: Coin, +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/types.rs b/contracts/injective-cosmwasm-stargate-example/src/types.rs new file mode 100644 index 00000000..e4e3642e --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/types.rs @@ -0,0 +1,170 @@ +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive( + Clone, + PartialEq, + Eq, + ::prost::Message, + ::serde::Serialize, + ::serde::Deserialize, + ::schemars::JsonSchema, + // CosmwasmExt, +)] +// #[proto_message(type_url = "/injective.exchange.v1beta1.OrderInfo")] +pub struct OrderInfo { + /// bytes32 subaccount ID that created the order + #[prost(string, tag = "1")] + #[serde(alias = "subaccountID")] + pub subaccount_id: ::prost::alloc::string::String, + /// address fee_recipient address that will receive fees for the order + #[prost(string, tag = "2")] + pub fee_recipient: ::prost::alloc::string::String, + /// price of the order + #[prost(string, tag = "3")] + pub price: ::prost::alloc::string::String, + /// quantity of the order + #[prost(string, tag = "4")] + pub quantity: ::prost::alloc::string::String, +} + +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive( + Clone, + PartialEq, + Eq, + ::prost::Message, + ::serde::Serialize, + ::serde::Deserialize, + ::schemars::JsonSchema, + // CosmwasmExt, +)] +// #[proto_message(type_url = "/injective.exchange.v1beta1.SpotOrder")] +pub struct SpotOrder { + /// market_id represents the unique ID of the market + #[prost(string, tag = "1")] + #[serde(alias = "marketID")] + pub market_id: ::prost::alloc::string::String, + /// order_info contains the information of the order + #[prost(message, optional, tag = "2")] + pub order_info: ::core::option::Option, + /// order types + #[prost(enumeration = "OrderType", tag = "3")] + // #[serde( + // serialize_with = "crate::serde::as_str::serialize", + // deserialize_with = "crate::serde::as_str::deserialize" + // )] + pub order_type: i32, + /// trigger_price is the trigger price used by stop/take orders + #[prost(string, tag = "4")] + pub trigger_price: ::prost::alloc::string::String, +} + +/// MsgCreateSpotMarketOrder defines a SDK message for creating a new spot market +/// order. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive( + Clone, + PartialEq, + Eq, + ::prost::Message, + ::serde::Serialize, + ::serde::Deserialize, + ::schemars::JsonSchema, + // CosmwasmExt, +)] +// #[proto_message(type_url = "/injective.exchange.v1beta1.MsgCreateSpotMarketOrder")] +pub struct MsgCreateSpotMarketOrder { + #[prost(string, tag = "1")] + pub sender: ::prost::alloc::string::String, + #[prost(message, optional, tag = "2")] + pub order: ::core::option::Option, +} + +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive( + Clone, + PartialEq, + Eq, + ::prost::Message, + ::serde::Serialize, + ::serde::Deserialize, + ::schemars::JsonSchema, + // CosmwasmExt, +)] +// #[proto_message(type_url = "/injective.exchange.v1beta1.MsgCreateSpotLimitOrder")] +pub struct MsgCreateSpotLimitOrder { + #[prost(string, tag = "1")] + pub sender: ::prost::alloc::string::String, + #[prost(message, optional, tag = "2")] + pub order: ::core::option::Option, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +#[derive(::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)] +pub enum OrderType { + Unspecified = 0, + Buy = 1, + Sell = 2, + StopBuy = 3, + StopSell = 4, + TakeBuy = 5, + TakeSell = 6, + BuyPo = 7, + SellPo = 8, + BuyAtomic = 9, + SellAtomic = 10, +} + +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive( + Clone, + PartialEq, + Eq, + ::prost::Message, + ::serde::Serialize, + ::serde::Deserialize, + ::schemars::JsonSchema, + //CosmwasmExt +)] +//#[proto_message(type_url = "/injective.exchange.v1beta1.MsgCreateDerivativeLimitOrder")] +pub struct MsgCreateDerivativeLimitOrder { + #[prost(string, tag = "1")] + pub sender: ::prost::alloc::string::String, + #[prost(message, optional, tag = "2")] + pub order: ::core::option::Option, +} + +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive( + Clone, + PartialEq, + Eq, + ::prost::Message, + ::serde::Serialize, + ::serde::Deserialize, + ::schemars::JsonSchema, + // CosmwasmExt, +)] +// #[proto_message(type_url = "/injective.exchange.v1beta1.DerivativeOrder")] +pub struct DerivativeOrder { + /// market_id represents the unique ID of the market + #[prost(string, tag = "1")] + #[serde(alias = "marketID")] + pub market_id: ::prost::alloc::string::String, + /// order_info contains the information of the order + #[prost(message, optional, tag = "2")] + pub order_info: ::core::option::Option, + /// order types + #[prost(enumeration = "OrderType", tag = "3")] + // #[serde( + // serialize_with = "crate::serde::as_str::serialize", + // deserialize_with = "crate::serde::as_str::deserialize" + // )] + pub order_type: i32, + /// margin is the margin used by the limit order + #[prost(string, tag = "4")] + pub margin: ::prost::alloc::string::String, + /// trigger_price is the trigger price used by stop/take orders + #[prost(string, tag = "5")] + pub trigger_price: ::prost::alloc::string::String, +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/utils.rs b/contracts/injective-cosmwasm-stargate-example/src/utils.rs new file mode 100644 index 00000000..9b5eaf92 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/utils.rs @@ -0,0 +1,833 @@ +use crate::msg::{InstantiateMsg, MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT, MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT}; +use cosmwasm_std::{coin, Addr, Coin}; +use injective_cosmwasm::{checked_address_to_subaccount_id, SubaccountId}; +use injective_math::{scale::Scaled, FPDecimal}; +use injective_std::{ + shim::{Any, Timestamp}, + types::{ + cosmos::{ + authz::v1beta1::{GenericAuthorization, Grant, MsgGrant, MsgRevoke, MsgRevokeResponse}, + bank::v1beta1::{MsgSend, SendAuthorization}, + base::v1beta1::Coin as BaseCoin, + gov::{ + v1::{MsgSubmitProposal, MsgVote}, + v1beta1::MsgSubmitProposal as MsgSubmitProposalV1Beta1, + }, + }, + injective::{ + exchange::v1beta1::{ + DerivativeOrder, MsgCreateDerivativeLimitOrder, MsgCreateSpotLimitOrder, MsgInstantPerpetualMarketLaunch, MsgInstantSpotMarketLaunch, + OrderInfo, OrderType, QueryDerivativeMarketsRequest, QuerySpotMarketsRequest, SpotOrder, + }, + insurance::v1beta1::MsgCreateInsuranceFund, + oracle::v1beta1::{ + GrantPriceFeederPrivilegeProposal, MsgRelayPriceFeedPrice, MsgRelayPythPrices, MsgUpdateParams, OracleType, Params, PriceAttestation, + }, + }, + }, +}; +use injective_test_tube::{ + injective_cosmwasm::get_default_subaccount_id_for_checked_address, Account, Authz, Bank, Exchange, ExecuteResponse, Gov, InjectiveTestApp, + Insurance, Module, Oracle, Runner, SigningAccount, Wasm, +}; +use injective_testing::human_to_i64; +use prost::Message; +use std::{collections::HashMap, ops::Neg, str::FromStr}; + +pub const EXCHANGE_DECIMALS: i32 = 18i32; +pub const BASE_DECIMALS: i32 = 18i32; +pub const ATOM_DECIMALS: i32 = 8i32; +pub const QUOTE_DECIMALS: i32 = 6i32; + +pub const ATOM_DENOM: &str = "atom"; +pub const BASE_DENOM: &str = "inj"; +pub const QUOTE_DENOM: &str = "usdt"; +pub const INJ_PYTH_PRICE_ID: &str = "0x7a5bc1d2b56ad029048cd63964b3ad2776eadf812edc1a43a31406cb54bff592"; +pub const USDT_PYTH_PRICE_ID: &str = "0x1fc18861232290221461220bd4e2acd1dcdfbc89c84092c93c18bdc7756c1588"; +pub const GOV_MODULE_ADDRESS: &str = "inj10d07y265gmmuvt4z0w9aw880jnsr700jstypyt"; + +pub struct UserInfo { + pub account: SigningAccount, + pub subaccount_id: SubaccountId, +} +pub struct Setup { + pub app: InjectiveTestApp, + pub owner: SigningAccount, + pub signer: SigningAccount, + pub validator: SigningAccount, + pub users: Vec, + pub denoms: HashMap, + pub contract_address: String, + pub code_id: u64, + pub market_id: Option, +} + +pub enum ExchangeType { + Spot, + Derivative, + None, +} + +impl Setup { + pub fn new(exchange_type: ExchangeType) -> Self { + let app = InjectiveTestApp::new(); + let wasm = Wasm::new(&app); + let mut market_id = None; + + let mut denoms = HashMap::new(); + denoms.insert("atom".to_string(), ATOM_DENOM.to_string()); + denoms.insert("quote".to_string(), QUOTE_DENOM.to_string()); + denoms.insert("base".to_string(), BASE_DENOM.to_string()); + + let signer = app.init_account(&[str_coin("1000000", BASE_DENOM, BASE_DECIMALS)]).unwrap(); + + let validator = app.get_first_validator_signing_account(BASE_DENOM.to_string(), 1.2f64).unwrap(); + + let owner = app + .init_account(&[ + str_coin("1000000", ATOM_DENOM, ATOM_DECIMALS), + str_coin("1000000", BASE_DENOM, BASE_DECIMALS), + str_coin("1000000", QUOTE_DENOM, QUOTE_DECIMALS), + ]) + .unwrap(); + + let mut users: Vec = Vec::new(); + for _ in 0..10 { + let user = app + .init_account(&[ + str_coin("1000000", ATOM_DENOM, ATOM_DECIMALS), + str_coin("1000000", BASE_DENOM, BASE_DECIMALS), + str_coin("1000", QUOTE_DENOM, QUOTE_DECIMALS), + ]) + .unwrap(); + + let user_subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(user.address()), 0u32); + + users.push(UserInfo { + account: user, + subaccount_id: user_subaccount_id, + }); + } + + let wasm_byte_code = std::fs::read(wasm_file("injective_cosmwasm_stargate_example".to_string())).unwrap(); + let code_id = wasm.store_code(&wasm_byte_code, None, &owner).unwrap().data.code_id; + + // Instantiate contract + let contract_address: String = wasm + .instantiate(code_id, &InstantiateMsg {}, Some(&owner.address()), Some("mock-contract"), &[], &owner) + .unwrap() + .data + .address; + + assert!(!contract_address.is_empty(), "Contract address is empty"); + + send(&Bank::new(&app), "1000000000000000000000", BASE_DENOM, &owner, &validator); + + launch_insurance_fund( + &app, + &owner, + "INJ/USDT", + denoms["quote"].as_str(), + denoms["base"].as_str(), + denoms["quote"].as_str(), + OracleType::PriceFeed, + ); + + launch_price_feed_oracle( + &app, + &signer, + &validator, + denoms["base"].as_str(), + denoms["quote"].as_str(), + human_to_dec("10.01", BASE_DECIMALS).to_string(), + ); + + match exchange_type { + ExchangeType::Spot => { + let exchange = Exchange::new(&app); + market_id = Some(launch_spot_market(&exchange, &owner, "INJ/USDT".to_string())); + } + ExchangeType::Derivative => { + let exchange = Exchange::new(&app); + market_id = Some(launch_perp_market(&exchange, &owner, "INJ/USDT".to_string())); + } + ExchangeType::None => {} + } + + Self { + app, + owner, + signer, + validator, + users, + denoms, + contract_address, + code_id, + market_id, + } + } +} + +impl Default for Setup { + fn default() -> Self { + Self::new(ExchangeType::None) + } +} + +pub fn wasm_file(contract_name: String) -> String { + let snaked_name = contract_name.replace('-', "_"); + let arch = std::env::consts::ARCH; + + let target = format!("../../target/wasm32-unknown-unknown/release/{snaked_name}.wasm"); + + let artifacts_dir = std::env::var("ARTIFACTS_DIR_PATH").unwrap_or_else(|_| "artifacts".to_string()); + let arch_target = format!("../../{artifacts_dir}/{snaked_name}-{arch}.wasm"); + + if std::path::Path::new(&target).exists() { + target + } else if std::path::Path::new(&arch_target).exists() { + arch_target + } else { + format!("../../{artifacts_dir}/{snaked_name}.wasm") + } +} + +pub fn str_coin(human_amount: &str, denom: &str, decimals: i32) -> Coin { + let scaled_amount = human_to_dec(human_amount, decimals); + let as_int: u128 = scaled_amount.into(); + coin(as_int, denom) +} + +pub fn send(bank: &Bank, amount: &str, denom: &str, from: &SigningAccount, to: &SigningAccount) { + bank.send( + MsgSend { + from_address: from.address(), + to_address: to.address(), + amount: vec![BaseCoin { + amount: amount.to_string(), + denom: denom.to_string(), + }], + }, + from, + ) + .unwrap(); +} + +pub fn launch_price_feed_oracle( + app: &InjectiveTestApp, + signer: &SigningAccount, + validator: &SigningAccount, + base: &str, + quote: &str, + dec_price: String, +) { + let gov = Gov::new(app); + let oracle = Oracle::new(app); + + let mut buf = vec![]; + GrantPriceFeederPrivilegeProposal::encode( + &GrantPriceFeederPrivilegeProposal { + title: "test-proposal".to_string(), + description: "test-proposal".to_string(), + base: base.to_string(), + quote: quote.to_string(), + relayers: vec![signer.address()], + }, + &mut buf, + ) + .unwrap(); + + let res = gov + .submit_proposal_v1beta1( + MsgSubmitProposalV1Beta1 { + content: Some(Any { + type_url: "/injective.oracle.v1beta1.GrantPriceFeederPrivilegeProposal".to_string(), + value: buf, + }), + initial_deposit: vec![BaseCoin { + amount: "100000000000000000000".to_string(), + denom: "inj".to_string(), + }], + proposer: validator.address(), + }, + validator, + ) + .unwrap(); + + let proposal_id = res.events.iter().find(|e| e.ty == "submit_proposal").unwrap().attributes[0] + .value + .to_owned(); + + gov.vote( + MsgVote { + proposal_id: u64::from_str(&proposal_id).unwrap(), + voter: validator.address(), + option: 1i32, + metadata: "".to_string(), + }, + validator, + ) + .unwrap(); + + // NOTE: increase the block time in order to move past the voting period + app.increase_time(10u64); + + oracle + .relay_price_feed( + MsgRelayPriceFeedPrice { + sender: signer.address(), + base: vec![base.to_string()], + quote: vec![quote.to_string()], + price: vec![dec_price], // 1.2@18dp + }, + signer, + ) + .unwrap(); +} + +pub fn launch_insurance_fund( + app: &InjectiveTestApp, + signer: &SigningAccount, + ticker: &str, + quote: &str, + oracle_base: &str, + oracle_quote: &str, + oracle_type: OracleType, +) { + let insurance = Insurance::new(app); + + insurance + .create_insurance_fund( + MsgCreateInsuranceFund { + sender: signer.address(), + ticker: ticker.to_string(), + quote_denom: quote.to_string(), + oracle_base: oracle_base.to_string(), + oracle_quote: oracle_quote.to_string(), + oracle_type: oracle_type as i32, + expiry: -1i64, + initial_deposit: Some(BaseCoin { + amount: human_to_dec("1_000", QUOTE_DECIMALS).to_string(), + denom: quote.to_string(), + }), + }, + signer, + ) + .unwrap(); +} + +pub fn launch_spot_market(exchange: &Exchange, signer: &SigningAccount, ticker: String) -> String { + exchange + .instant_spot_market_launch( + MsgInstantSpotMarketLaunch { + sender: signer.address(), + ticker: ticker.clone(), + base_denom: BASE_DENOM.to_string(), + quote_denom: QUOTE_DENOM.to_string(), + min_price_tick_size: dec_to_proto(FPDecimal::must_from_str("0.000000000000001")), + min_quantity_tick_size: dec_to_proto(FPDecimal::must_from_str("1")), + }, + signer, + ) + .unwrap(); + + get_spot_market_id(exchange, ticker) +} + +pub fn get_spot_market_id(exchange: &Exchange, ticker: String) -> String { + let spot_markets = exchange + .query_spot_markets(&QuerySpotMarketsRequest { + status: "Active".to_string(), + market_ids: vec![], + }) + .unwrap() + .markets; + + let market = spot_markets.iter().find(|m| m.ticker == ticker).unwrap(); + market.market_id.to_string() +} + +pub fn launch_perp_market(exchange: &Exchange, signer: &SigningAccount, ticker: String) -> String { + exchange + .instant_perpetual_market_launch( + MsgInstantPerpetualMarketLaunch { + sender: signer.address(), + ticker: ticker.to_owned(), + quote_denom: "usdt".to_string(), + oracle_base: "inj".to_string(), + oracle_quote: "usdt".to_string(), + oracle_scale_factor: 6u32, + oracle_type: 2i32, + maker_fee_rate: "0".to_owned(), + taker_fee_rate: "0".to_owned(), + initial_margin_ratio: "195000000000000000".to_owned(), + maintenance_margin_ratio: "50000000000000000".to_owned(), + min_price_tick_size: "1000000000000000000000".to_owned(), + min_quantity_tick_size: "1000000000000000".to_owned(), + }, + signer, + ) + .unwrap(); + + get_perpetual_market_id(exchange, ticker) +} + +pub fn get_perpetual_market_id(exchange: &Exchange, ticker: String) -> String { + let perpetual_markets = exchange + .query_derivative_markets(&QueryDerivativeMarketsRequest { + status: "Active".to_string(), + market_ids: vec![], + with_mid_price_and_tob: false, + }) + .unwrap() + .markets; + + let market = perpetual_markets + .iter() + .filter(|m| m.market.is_some()) + .find(|m| m.market.as_ref().unwrap().ticker == ticker) + .unwrap() + .market + .as_ref() + .unwrap(); + + market.market_id.to_string() +} + +#[derive(Clone)] +pub struct HumanOrder { + pub price: String, + pub quantity: String, + pub order_type: OrderType, +} +pub fn add_spot_order_as(app: &InjectiveTestApp, market_id: String, trader: &UserInfo, price: String, quantity: String, order_type: OrderType) { + let exchange = Exchange::new(app); + exchange + .create_spot_limit_order( + MsgCreateSpotLimitOrder { + sender: trader.account.address().clone(), + order: Some(SpotOrder { + market_id: market_id.to_owned(), + order_info: Some(OrderInfo { + subaccount_id: trader.subaccount_id.to_string(), + fee_recipient: trader.account.address(), + price, + quantity, + }), + order_type: order_type.into(), + trigger_price: "".to_string(), + }), + }, + &trader.account, + ) + .unwrap(); +} + +pub fn add_spot_orders(app: &InjectiveTestApp, market_id: String, orders: Vec) { + let account = app + .init_account(&[ + str_coin("1000000", BASE_DENOM, BASE_DECIMALS), + str_coin("1000000", QUOTE_DENOM, QUOTE_DECIMALS), + ]) + .unwrap(); + + let subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(account.address()), 0u32); + + let trader = UserInfo { account, subaccount_id }; + + for order in orders { + let (price, quantity) = scale_price_quantity_for_spot_market(order.price.as_str(), order.quantity.as_str(), &BASE_DECIMALS, "E_DECIMALS); + add_spot_order_as(app, market_id.to_owned(), &trader, price, quantity, order.order_type); + } +} + +pub fn get_initial_liquidity_orders_vector() -> Vec { + vec![ + HumanOrder { + price: "15".to_string(), + quantity: "10".to_string(), + order_type: OrderType::Sell, + }, + HumanOrder { + price: "12".to_string(), + quantity: "5".to_string(), + order_type: OrderType::Sell, + }, + HumanOrder { + price: "10.2".to_string(), + quantity: "5".to_string(), + order_type: OrderType::Sell, + }, + HumanOrder { + price: "10.1".to_string(), + quantity: "10".to_string(), + order_type: OrderType::Sell, + }, + HumanOrder { + price: "9.9".to_string(), + quantity: "10".to_string(), + order_type: OrderType::Buy, + }, + HumanOrder { + price: "9.8".to_string(), + quantity: "5".to_string(), + order_type: OrderType::Buy, + }, + HumanOrder { + price: "8".to_string(), + quantity: "5".to_string(), + order_type: OrderType::Buy, + }, + HumanOrder { + price: "5".to_string(), + quantity: "10".to_string(), + order_type: OrderType::Buy, + }, + ] +} + +pub fn add_spot_initial_liquidity(app: &InjectiveTestApp, market_id: String) { + add_spot_orders(app, market_id, get_initial_liquidity_orders_vector()); +} + +pub fn get_initial_perp_liquidity_orders_vector() -> Vec { + vec![ + HumanOrder { + price: "10.2".to_string(), + quantity: "2".to_string(), + order_type: OrderType::Sell, + }, + HumanOrder { + price: "10.1".to_string(), + quantity: "1".to_string(), + order_type: OrderType::Sell, + }, + HumanOrder { + price: "9.9".to_string(), + quantity: "1".to_string(), + order_type: OrderType::Buy, + }, + HumanOrder { + price: "9.8".to_string(), + quantity: "2".to_string(), + order_type: OrderType::Buy, + }, + ] +} + +pub fn add_derivative_order_as( + app: &InjectiveTestApp, + market_id: String, + trader: &SigningAccount, + price: String, + quantity: String, + order_type: OrderType, + margin: String, +) { + let exchange = Exchange::new(app); + exchange + .create_derivative_limit_order( + MsgCreateDerivativeLimitOrder { + sender: trader.address(), + order: Some(DerivativeOrder { + market_id: market_id.to_owned(), + order_info: Some(OrderInfo { + subaccount_id: get_default_subaccount_id_for_checked_address(&Addr::unchecked(trader.address())) + .as_str() + .to_string(), + fee_recipient: trader.address(), + price, + quantity, + }), + margin, + order_type: order_type.into(), + trigger_price: "".to_string(), + }), + }, + trader, + ) + .unwrap(); +} + +pub fn add_derivative_orders(app: &InjectiveTestApp, market_id: String, orders: Vec, margin: Option) { + let trader = app + .init_account(&[ + str_coin("1000000", BASE_DENOM, BASE_DECIMALS), + str_coin("1000000", QUOTE_DENOM, QUOTE_DECIMALS), + ]) + .unwrap(); + + let margin = margin.unwrap_or("2".into()); + + for order in orders { + let (price, quantity, order_margin) = + scale_price_quantity_perp_market(order.price.as_str(), order.quantity.as_str(), &margin, "E_DECIMALS); + add_derivative_order_as(app, market_id.to_owned(), &trader, price, quantity, order.order_type, order_margin); + } +} + +pub fn add_perp_initial_liquidity(app: &InjectiveTestApp, market_id: String) { + add_derivative_orders(app, market_id, get_initial_perp_liquidity_orders_vector(), None); +} + +pub fn revoke_authorization(app: &InjectiveTestApp, granter: &SigningAccount, grantee: String, msg_type_url: String) { + let _res: ExecuteResponse = app + .execute_multiple( + &[( + MsgRevoke { + granter: granter.address(), + grantee, + msg_type_url, + }, + MsgRevoke::TYPE_URL, + )], + granter, + ) + .unwrap(); +} + +pub fn create_generic_authorization(app: &InjectiveTestApp, granter: &SigningAccount, grantee: String, msg: String, expiration: Option) { + let authz = Authz::new(app); + + let mut buf = vec![]; + GenericAuthorization::encode(&GenericAuthorization { msg }, &mut buf).unwrap(); + + authz + .grant( + MsgGrant { + granter: granter.address(), + grantee, + grant: Some(Grant { + authorization: Some(Any { + type_url: "/cosmos.authz.v1beta1.GenericAuthorization".to_string(), + value: buf.clone(), + }), + expiration, + }), + }, + granter, + ) + .unwrap(); +} + +pub fn create_send_authorization(app: &InjectiveTestApp, granter: &SigningAccount, grantee: String, amount: BaseCoin, expiration: Option) { + let authz = Authz::new(app); + + let mut buf = vec![]; + SendAuthorization::encode( + &SendAuthorization { + spend_limit: vec![amount], + allow_list: vec![], + }, + &mut buf, + ) + .unwrap(); + + authz + .grant( + MsgGrant { + granter: granter.address(), + grantee, + grant: Some(Grant { + authorization: Some(Any { + type_url: "/cosmos.bank.v1beta1.SendAuthorization".to_string(), + value: buf.clone(), + }), + expiration, + }), + }, + granter, + ) + .unwrap(); +} + +pub fn execute_all_authorizations(app: &InjectiveTestApp, granter: &SigningAccount, grantee: String) { + create_generic_authorization(app, granter, grantee.clone(), MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT.to_string(), None); + + create_generic_authorization( + app, + granter, + grantee.clone(), + MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT.to_string(), + None, + ); + + create_generic_authorization( + app, + granter, + grantee.clone(), + "/injective.exchange.v1beta1.MsgCreateDerivativeMarketOrder".to_string(), + None, + ); + + create_generic_authorization( + app, + granter, + grantee.clone(), + "/injective.exchange.v1beta1.MsgBatchUpdateOrders".to_string(), + None, + ); + + create_generic_authorization(app, granter, grantee, "/injective.exchange.v1beta1.MsgWithdraw".to_string(), None); +} + +// Human Utils +pub fn human_to_proto(raw_number: &str, decimals: i32) -> String { + FPDecimal::must_from_str(&raw_number.replace('_', "")).scaled(18 + decimals).to_string() +} + +pub fn human_to_dec(raw_number: &str, decimals: i32) -> FPDecimal { + FPDecimal::must_from_str(&raw_number.replace('_', "")).scaled(decimals) +} + +pub fn dec_to_proto(val: FPDecimal) -> String { + val.scaled(18).to_string() +} + +pub fn scale_price_quantity_for_spot_market(price: &str, quantity: &str, base_decimals: &i32, quote_decimals: &i32) -> (String, String) { + let (scaled_price, scaled_quantity) = scale_price_quantity_for_spot_market_dec(price, quantity, base_decimals, quote_decimals); + (dec_to_proto(scaled_price), dec_to_proto(scaled_quantity)) +} + +pub fn scale_price_quantity_for_spot_market_dec(price: &str, quantity: &str, base_decimals: &i32, quote_decimals: &i32) -> (FPDecimal, FPDecimal) { + let price_dec = FPDecimal::must_from_str(price.replace('_', "").as_str()); + let quantity_dec = FPDecimal::must_from_str(quantity.replace('_', "").as_str()); + + let scaled_price = price_dec.scaled(quote_decimals - base_decimals); + let scaled_quantity = quantity_dec.scaled(*base_decimals); + + (scaled_price, scaled_quantity) +} + +pub fn scale_price_quantity_perp_market(price: &str, quantity: &str, margin_ratio: &str, quote_decimals: &i32) -> (String, String, String) { + let (scaled_price, scaled_quantity, scaled_margin) = scale_price_quantity_perp_market_dec(price, quantity, margin_ratio, quote_decimals); + + (dec_to_proto(scaled_price), dec_to_proto(scaled_quantity), dec_to_proto(scaled_margin)) +} + +pub fn scale_price_quantity_perp_market_dec( + price: &str, + quantity: &str, + margin_ratio: &str, + quote_decimals: &i32, +) -> (FPDecimal, FPDecimal, FPDecimal) { + let price_dec = FPDecimal::must_from_str(price.replace('_', "").as_str()); + let quantity_dec = FPDecimal::must_from_str(quantity.replace('_', "").as_str()); + let margin_ratio_dec = FPDecimal::must_from_str(margin_ratio.replace('_', "").as_str()); + + let scaled_price = price_dec.scaled(*quote_decimals); + let scaled_quantity = quantity_dec; + + let scaled_margin = (price_dec * quantity_dec * margin_ratio_dec).scaled(*quote_decimals); + + (scaled_price, scaled_quantity, scaled_margin) +} + +pub fn set_address_of_pyth_contract(app: &InjectiveTestApp, validator: &SigningAccount, pyth_address: &SigningAccount) { + let gov = Gov::new(app); + + let mut buf = vec![]; + MsgUpdateParams::encode( + &MsgUpdateParams { + authority: GOV_MODULE_ADDRESS.to_string(), + params: Some(Params { + pyth_contract: pyth_address.address(), + }), + }, + &mut buf, + ) + .unwrap(); + + let res = gov + .submit_proposal( + MsgSubmitProposal { + messages: vec![Any { + type_url: "/injective.oracle.v1beta1.MsgUpdateParams".to_string(), + value: buf, + }], + initial_deposit: vec![BaseCoin { + amount: "100000000000000000000".to_string(), + denom: "inj".to_string(), + }], + proposer: validator.address(), + metadata: "".to_string(), + title: "Set Pyth contract address".to_string(), + summary: "Set Pyth contract address".to_string(), + }, + validator, + ) + .unwrap(); + + let proposal_id = res.events.iter().find(|e| e.ty == "submit_proposal").unwrap().attributes[0] + .value + .to_owned(); + + gov.vote( + MsgVote { + proposal_id: u64::from_str(&proposal_id).unwrap(), + voter: validator.address(), + option: 1i32, + metadata: "".to_string(), + }, + validator, + ) + .unwrap(); + + // NOTE: increase the block time in order to move past the voting period + app.increase_time(11u64); +} + +pub fn relay_pyth_price(oracle: &Oracle, price_attestations: Vec, pyth_address: &SigningAccount) { + let pyth_price_msg = MsgRelayPythPrices { + sender: pyth_address.address(), + price_attestations, + }; + + oracle.relay_pyth_prices(pyth_price_msg, pyth_address).unwrap(); +} + +pub fn create_some_inj_price_attestation(human_price: &str, decimal_precision: i32, publish_time: i64) -> PriceAttestation { + if decimal_precision < 0 { + panic!("Desired exponent cannot be negative") + }; + + let (price_i64, exponent_to_use) = if decimal_precision == 1 { + (human_price.parse::().unwrap(), 1) + } else { + (human_to_i64(human_price, decimal_precision), decimal_precision.neg()) + }; + + PriceAttestation { + price_id: INJ_PYTH_PRICE_ID.to_string(), + price: price_i64, + conf: 500, + expo: exponent_to_use, + ema_price: price_i64, + ema_conf: 2000, + ema_expo: exponent_to_use, + publish_time, + } +} + +pub fn create_some_usdt_price_attestation(human_price: &str, decimal_precision: i32, publish_time: i64) -> PriceAttestation { + if decimal_precision < 0 { + panic!("Desired exponent cannot be negative") + }; + + let (price_i64, exponent_to_use) = if decimal_precision == 0 { + (human_price.parse::().unwrap(), 0) + } else { + (human_to_i64(human_price, decimal_precision), decimal_precision.neg()) + }; + + PriceAttestation { + price_id: USDT_PYTH_PRICE_ID.to_string(), + price: price_i64, + conf: 500, + expo: exponent_to_use, + ema_price: price_i64, + ema_conf: 2000, + ema_expo: exponent_to_use, + publish_time, + } +} From 122e45c2e29cc8a77a47761693612c4e27790494 Mon Sep 17 00:00:00 2001 From: jbernal87 Date: Wed, 24 Apr 2024 15:23:43 +0200 Subject: [PATCH 02/19] make query functional --- contracts/injective-cosmwasm-stargate-example/src/query.rs | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/contracts/injective-cosmwasm-stargate-example/src/query.rs b/contracts/injective-cosmwasm-stargate-example/src/query.rs index 3feb67b1..19f45ae6 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/query.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/query.rs @@ -23,9 +23,12 @@ pub fn handle_query_stargate(querier: &QuerierWrapper, pa contract_err ))), SystemResult::Ok(ContractResult::Ok(value)) => Ok(value), - }?; + }? + .to_string(); + let decoded_value = BASE64_STANDARD + .decode(value).map_err(|_| StdError::generic_err("Decoding base64 value"))?; - to_json_binary(&QueryStargateResponse { value: String::from(decoded_value)? }) + to_json_binary(&QueryStargateResponse { value: String::from_utf8(decoded_value)? }) } From f82826b1a4e012d761d2b5216b64e0c586d0db25 Mon Sep 17 00:00:00 2001 From: jbernal87 Date: Wed, 24 Apr 2024 21:45:05 +0200 Subject: [PATCH 03/19] small refactor --- Cargo.lock | 458 ++++++++++++------ .../src/contract.rs | 3 +- .../src/testing/mod.rs | 2 + .../src/testing/test_bank.rs | 38 +- .../src/testing/test_exchange.rs | 32 ++ .../src/testing/type_helpers.rs | 19 + packages/injective-protobuf/src/proto/mod.rs | 4 +- 7 files changed, 355 insertions(+), 201 deletions(-) create mode 100644 contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs diff --git a/Cargo.lock b/Cargo.lock index f10c7ffc..e552a8e7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -416,7 +416,27 @@ dependencies = [ "serde 1.0.197", "serde_json 1.0.111", "subtle-encoding", - "tendermint", + "tendermint 0.32.2", + "thiserror", +] + +[[package]] +name = "cosmrs" +version = "0.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47126f5364df9387b9d8559dcef62e99010e1d4098f39eb3f7ee4b5c254e40ea" +dependencies = [ + "bip32", + "cosmos-sdk-proto 0.20.0", + "ecdsa 0.16.9", + "eyre", + "k256 0.13.2", + "rand_core 0.6.4", + "serde 1.0.197", + "serde_json 1.0.111", + "signature 2.2.0", + "subtle-encoding", + "tendermint 0.34.1", "tendermint-rpc", "thiserror", ] @@ -549,15 +569,6 @@ dependencies = [ "typenum", ] -[[package]] -name = "ct-logs" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1a816186fa68d9e426e3cb4ae4dff1fcd8e4a2c34b781bf7a822574a0d0aac8" -dependencies = [ - "sct", -] - [[package]] name = "curve25519-dalek" version = "3.2.0" @@ -906,6 +917,15 @@ dependencies = [ "zeroize", ] +[[package]] +name = "encoding_rs" +version = "0.8.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59" +dependencies = [ + "cfg-if", +] + [[package]] name = "enumset" version = "1.1.3" @@ -1089,7 +1109,6 @@ checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0" dependencies = [ "futures-channel", "futures-core", - "futures-executor", "futures-io", "futures-sink", "futures-task", @@ -1112,34 +1131,12 @@ version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" -[[package]] -name = "futures-executor" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d" -dependencies = [ - "futures-core", - "futures-task", - "futures-util", -] - [[package]] name = "futures-io" version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1" -[[package]] -name = "futures-macro" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.48", -] - [[package]] name = "futures-sink" version = "0.3.30" @@ -1158,16 +1155,11 @@ version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" dependencies = [ - "futures-channel", "futures-core", - "futures-io", - "futures-macro", "futures-sink", "futures-task", - "memchr", "pin-project-lite", "pin-utils", - "slab", ] [[package]] @@ -1268,30 +1260,6 @@ version = "0.14.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604" -[[package]] -name = "headers" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06683b93020a07e3dbcf5f8c0f6d40080d725bea7936fc01ad345c01b97dc270" -dependencies = [ - "base64 0.21.5", - "bytes", - "headers-core", - "http", - "httpdate", - "mime", - "sha1", -] - -[[package]] -name = "headers-core" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7f66481bfee273957b1f20485a4ff3362987f85b2c236580d81b4eb7a326429" -dependencies = [ - "http", -] - [[package]] name = "heapsize" version = "0.4.2" @@ -1407,41 +1375,18 @@ dependencies = [ "want", ] -[[package]] -name = "hyper-proxy" -version = "0.9.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca815a891b24fdfb243fa3239c86154392b0953ee584aa1a2a1f66d20cbe75cc" -dependencies = [ - "bytes", - "futures", - "headers", - "http", - "hyper", - "hyper-rustls", - "rustls-native-certs", - "tokio", - "tokio-rustls", - "tower-service", - "webpki", -] - [[package]] name = "hyper-rustls" -version = "0.22.1" +version = "0.24.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f9f7a97316d44c0af9b0301e65010573a853a9fc97046d7331d7f6bc0fd5a64" +checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590" dependencies = [ - "ct-logs", "futures-util", + "http", "hyper", - "log", "rustls", - "rustls-native-certs", "tokio", "tokio-rustls", - "webpki", - "webpki-roots", ] [[package]] @@ -1577,7 +1522,7 @@ dependencies = [ "injective-math 0.2.4", "injective-protobuf", "injective-std 0.1.5", - "injective-test-tube", + "injective-test-tube 1.1.7", "injective-testing 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", "prost 0.11.9", "protobuf 3.4.0", @@ -1586,6 +1531,30 @@ dependencies = [ "thiserror", ] +[[package]] +name = "injective-cosmwasm-stargate-example" +version = "0.0.1" +dependencies = [ + "base64 0.21.5", + "cosmos-sdk-proto 0.20.0", + "cosmwasm-schema", + "cosmwasm-std", + "cw-storage-plus 1.2.0", + "cw2 0.16.0", + "injective-cosmwasm 0.2.22", + "injective-math 0.2.4", + "injective-protobuf", + "injective-std 0.1.6", + "injective-test-tube 1.1.8", + "injective-testing 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", + "prost 0.12.3", + "protobuf 3.4.0", + "schemars", + "serde 1.0.197", + "serde_json 1.0.111", + "thiserror", +] + [[package]] name = "injective-math" version = "0.2.4" @@ -1666,7 +1635,7 @@ checksum = "61cb772fd4c8c1da872b742633e73928cbf1cf0505a09ec8ad41934a4d7f10b4" dependencies = [ "base64 0.13.1", "bindgen", - "cosmrs", + "cosmrs 0.14.0", "cosmwasm-std", "hex", "injective-cosmwasm 0.2.18", @@ -1678,6 +1647,24 @@ dependencies = [ "thiserror", ] +[[package]] +name = "injective-test-tube" +version = "1.1.8" +dependencies = [ + "base64 0.21.5", + "bindgen", + "cosmrs 0.15.0", + "cosmwasm-std", + "hex", + "injective-cosmwasm 0.2.18", + "injective-std 0.1.6", + "prost 0.12.3", + "serde 1.0.197", + "serde_json 1.0.111", + "test-tube-inj", + "thiserror", +] + [[package]] name = "injective-testing" version = "0.1.6" @@ -1712,6 +1699,12 @@ dependencies = [ "tiny-keccak", ] +[[package]] +name = "ipnet" +version = "2.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3" + [[package]] name = "itertools" version = "0.10.5" @@ -2089,9 +2082,9 @@ checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099" [[package]] name = "peg" -version = "0.7.0" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07c0b841ea54f523f7aa556956fbd293bcbe06f2e67d2eb732b7278aaf1d166a" +checksum = "400bcab7d219c38abf8bd7cc2054eb9bbbd4312d66f6a5557d572a203f646f61" dependencies = [ "peg-macros", "peg-runtime", @@ -2099,9 +2092,9 @@ dependencies = [ [[package]] name = "peg-macros" -version = "0.7.0" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5aa52829b8decbef693af90202711348ab001456803ba2a98eb4ec8fb70844c" +checksum = "46e61cce859b76d19090f62da50a9fe92bab7c2a5f09e183763559a2ac392c90" dependencies = [ "peg-runtime", "proc-macro2", @@ -2110,9 +2103,9 @@ dependencies = [ [[package]] name = "peg-runtime" -version = "0.7.0" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c719dcf55f09a3a7e764c6649ab594c18a177e3599c467983cdf644bfc0a4088" +checksum = "36bae92c60fa2398ce4678b98b2c4b5a7c61099961ca1fa305aec04a9ad28922" [[package]] name = "percent-encoding" @@ -2178,6 +2171,12 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" +[[package]] +name = "ppv-lite86" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" + [[package]] name = "primitive-types" version = "0.12.2" @@ -2377,6 +2376,27 @@ dependencies = [ "winapi", ] +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core 0.6.4", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core 0.6.4", +] + [[package]] name = "rand_core" version = "0.3.1" @@ -2445,6 +2465,47 @@ version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f" +[[package]] +name = "reqwest" +version = "0.11.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62" +dependencies = [ + "base64 0.21.5", + "bytes", + "encoding_rs", + "futures-core", + "futures-util", + "h2", + "http", + "http-body", + "hyper", + "hyper-rustls", + "ipnet", + "js-sys", + "log", + "mime", + "once_cell", + "percent-encoding", + "pin-project-lite", + "rustls", + "rustls-native-certs", + "rustls-pemfile", + "serde 1.0.197", + "serde_json 1.0.111", + "serde_urlencoded", + "sync_wrapper", + "system-configuration", + "tokio", + "tokio-rustls", + "tower-service", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "winreg", +] + [[package]] name = "rfc6979" version = "0.3.1" @@ -2468,17 +2529,17 @@ dependencies = [ [[package]] name = "ring" -version = "0.16.20" +version = "0.17.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc" +checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d" dependencies = [ "cc", + "cfg-if", + "getrandom", "libc", - "once_cell", "spin", "untrusted", - "web-sys", - "winapi", + "windows-sys 0.52.0", ] [[package]] @@ -2538,29 +2599,47 @@ dependencies = [ [[package]] name = "rustls" -version = "0.19.1" +version = "0.21.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35edb675feee39aec9c99fa5ff985081995a06d594114ae14cbe797ad7b7a6d7" +checksum = "7fecbfb7b1444f477b345853b1fce097a2c6fb637b2bfb87e6bc5db0f043fae4" dependencies = [ - "base64 0.13.1", "log", "ring", + "rustls-webpki", "sct", - "webpki", ] [[package]] name = "rustls-native-certs" -version = "0.5.0" +version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a07b7c1885bd8ed3831c289b7870b13ef46fe0e856d288c30d9cc17d75a2092" +checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00" dependencies = [ "openssl-probe", - "rustls", + "rustls-pemfile", "schannel", "security-framework", ] +[[package]] +name = "rustls-pemfile" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" +dependencies = [ + "base64 0.21.5", +] + +[[package]] +name = "rustls-webpki" +version = "0.101.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" +dependencies = [ + "ring", + "untrusted", +] + [[package]] name = "ryu" version = "1.0.16" @@ -2612,9 +2691,9 @@ dependencies = [ [[package]] name = "sct" -version = "0.6.1" +version = "0.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b362b83898e0e69f38515b82ee15aa80636befe47c3b6d3d89a911e78fc228ce" +checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414" dependencies = [ "ring", "untrusted", @@ -2810,14 +2889,15 @@ dependencies = [ ] [[package]] -name = "sha1" -version = "0.10.6" +name = "serde_urlencoded" +version = "0.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" dependencies = [ - "cfg-if", - "cpufeatures", - "digest 0.10.7", + "form_urlencoded", + "itoa", + "ryu", + "serde 1.0.197", ] [[package]] @@ -2891,9 +2971,9 @@ dependencies = [ [[package]] name = "spin" -version = "0.5.2" +version = "0.9.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d" +checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" [[package]] name = "spki" @@ -2976,6 +3056,33 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "sync_wrapper" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" + +[[package]] +name = "system-configuration" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "system-configuration-sys", +] + +[[package]] +name = "system-configuration-sys" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9" +dependencies = [ + "core-foundation-sys", + "libc", +] + [[package]] name = "tendermint" version = "0.32.2" @@ -3007,16 +3114,47 @@ dependencies = [ "zeroize", ] +[[package]] +name = "tendermint" +version = "0.34.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "15ab8f0a25d0d2ad49ac615da054d6a76aa6603ff95f7d18bafdd34450a1a04b" +dependencies = [ + "bytes", + "digest 0.10.7", + "ed25519", + "ed25519-consensus", + "flex-error", + "futures", + "k256 0.13.2", + "num-traits", + "once_cell", + "prost 0.12.3", + "prost-types 0.12.3", + "ripemd", + "serde 1.0.197", + "serde_bytes", + "serde_json 1.0.111", + "serde_repr", + "sha2 0.10.8", + "signature 2.2.0", + "subtle", + "subtle-encoding", + "tendermint-proto 0.34.1", + "time", + "zeroize", +] + [[package]] name = "tendermint-config" -version = "0.32.2" +version = "0.34.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71a72dbbea6dde12045d261f2c70c0de039125675e8a026c8d5ad34522756372" +checksum = "e1a02da769166e2052cd537b1a97c78017632c2d9e19266367b27e73910434fc" dependencies = [ "flex-error", "serde 1.0.197", "serde_json 1.0.111", - "tendermint", + "tendermint 0.34.1", "toml", "url", ] @@ -3059,30 +3197,28 @@ dependencies = [ [[package]] name = "tendermint-rpc" -version = "0.32.2" +version = "0.34.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d119d83a130537fc4a98c3c9eb6899ebe857fea4860400a61675bfb5f0b35129" +checksum = "71afae8bb5f6b14ed48d4e1316a643b6c2c3cbad114f510be77b4ed20b7b3e42" dependencies = [ "async-trait", "bytes", "flex-error", "futures", "getrandom", - "http", - "hyper", - "hyper-proxy", - "hyper-rustls", "peg", "pin-project", + "rand 0.8.5", + "reqwest", "semver", "serde 1.0.197", "serde_bytes", "serde_json 1.0.111", "subtle", "subtle-encoding", - "tendermint", + "tendermint 0.34.1", "tendermint-config", - "tendermint-proto 0.32.2", + "tendermint-proto 0.34.1", "thiserror", "time", "tokio", @@ -3103,14 +3239,14 @@ dependencies = [ [[package]] name = "test-tube-inj" -version = "1.1.1" +version = "1.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae2aa4f0386a041eea657c0d0b4438f1d757a231d0736c1b3413b9c84cfa36db" +checksum = "751b40929081e03c825df424a5a81645f2cea444654d96f0aad962f7be4e541e" dependencies = [ - "base64 0.13.1", - "cosmrs", + "base64 0.21.5", + "cosmrs 0.15.0", "cosmwasm-std", - "prost 0.11.9", + "prost 0.12.3", "serde 1.0.197", "serde_json 1.0.111", "tendermint-proto 0.32.2", @@ -3225,13 +3361,12 @@ dependencies = [ [[package]] name = "tokio-rustls" -version = "0.22.0" +version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc6844de72e57df1980054b38be3a9f4702aba4858be64dd700181a8a6d0e1b6" +checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" dependencies = [ "rustls", "tokio", - "webpki", ] [[package]] @@ -3341,9 +3476,9 @@ dependencies = [ [[package]] name = "untrusted" -version = "0.7.1" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a" +checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" [[package]] name = "url" @@ -3358,9 +3493,9 @@ dependencies = [ [[package]] name = "uuid" -version = "0.8.2" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7" +checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0" [[package]] name = "version_check" @@ -3418,6 +3553,18 @@ dependencies = [ "wasm-bindgen-shared", ] +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.39" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac36a15a220124ac510204aec1c3e5db8a22ab06fd6706d881dc6149f8ed9a12" +dependencies = [ + "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", +] + [[package]] name = "wasm-bindgen-macro" version = "0.2.89" @@ -3457,25 +3604,6 @@ dependencies = [ "wasm-bindgen", ] -[[package]] -name = "webpki" -version = "0.21.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8e38c0608262c46d4a56202ebabdeb094cef7e560ca7a226c6bf055188aa4ea" -dependencies = [ - "ring", - "untrusted", -] - -[[package]] -name = "webpki-roots" -version = "0.21.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aabe153544e473b775453675851ecc86863d2a81d786d741f6b76778f2a48940" -dependencies = [ - "webpki", -] - [[package]] name = "which" version = "4.4.2" @@ -3660,6 +3788,16 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04" +[[package]] +name = "winreg" +version = "0.50.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" +dependencies = [ + "cfg-if", + "windows-sys 0.48.0", +] + [[package]] name = "zeroize" version = "1.7.0" diff --git a/contracts/injective-cosmwasm-stargate-example/src/contract.rs b/contracts/injective-cosmwasm-stargate-example/src/contract.rs index ca303fd5..f9e66d55 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/contract.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/contract.rs @@ -5,7 +5,7 @@ use crate::{ handle_query_stargate, }, }; -use cosmwasm_std::{entry_point, Binary, Deps, DepsMut, Env, MessageInfo, Reply, Response, StdResult}; +use cosmwasm_std::{entry_point, Binary, Deps, DepsMut, Env, MessageInfo, Response, StdResult}; use cw2::set_contract_version; use injective_cosmwasm::{create_deposit_msg, InjectiveMsgWrapper, InjectiveQuerier, InjectiveQueryWrapper}; @@ -37,7 +37,6 @@ pub fn execute( #[cfg_attr(not(feature = "library"), entry_point)] pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult { - let querier = InjectiveQuerier::new(&deps.querier); match msg { QueryMsg::QueryStargate { path, query_request } => handle_query_stargate(&deps.querier, path, query_request), } diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs index 73ddca58..c98a9242 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs @@ -1 +1,3 @@ mod test_bank; +mod test_exchange; +mod type_helpers; diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs index a3a86801..1489dc01 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs @@ -12,6 +12,7 @@ use crate::{ }; use crate::msg::QueryStargateResponse; use serde_json::{Value, Map}; +use crate::testing::type_helpers::{AuthParams, ParamResponse}; use crate::utils::{BASE_DECIMALS, BASE_DENOM, str_coin}; #[test] @@ -40,45 +41,8 @@ fn test_msg_deposit() { // assert_eq!(response.get("params").unwrap().as_object().unwrap().get("max_memo_characters").unwrap().as_str().unwrap(), "256"); } -#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] -pub struct ParamResponse { - pub params: T, -} - -#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] -pub struct AuthParams { - pub max_memo_characters: String, - pub sig_verify_cost_ed25519: String, -} -#[test] -#[cfg_attr(not(feature = "integration"), ignore)] -fn test_exchange_param() { - let env = Setup::new(ExchangeType::None); - let wasm = Wasm::new(&env.app); - let user = &env.users[0]; - let subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(user.account.address()), 1u32); - // Execute contract - let query_msg = QueryMsg::QueryStargate { - path: "/injective.exchange.v1beta1.Query/QueryExchangeParams".to_string(), - query_request: "".to_string(), - }; - - let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); - let contract_response = contract_response.value; - println!("{:?}", contract_response); - let response: ParamResponse = from_json(&contract_response).unwrap(); - println!("{:?}", response); - let listing_fee_coin = str_coin("1000", BASE_DENOM, BASE_DECIMALS); - assert_eq!(response.params.spot_market_instant_listing_fee, listing_fee_coin); - assert_eq!(1,2) -} - -#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] -pub struct ExchangeParams { - pub spot_market_instant_listing_fee: Coin, -} diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs new file mode 100644 index 00000000..c9da0ea3 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs @@ -0,0 +1,32 @@ +use cosmwasm_std::{Addr, from_json}; +use injective_test_tube::{Account, Module, Wasm}; +use injective_cosmwasm::checked_address_to_subaccount_id; +use crate::msg::{QueryMsg, QueryStargateResponse}; +use crate::testing::type_helpers::ParamResponse; +use crate::testing::type_helpers::ExchangeParams; +use crate::utils::{BASE_DECIMALS, BASE_DENOM, ExchangeType, Setup, str_coin}; + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_exchange_param() { + let env = Setup::new(ExchangeType::None); + + let wasm = Wasm::new(&env.app); + let user = &env.users[0]; + + let subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(user.account.address()), 1u32); + // Execute contract + + let query_msg = QueryMsg::QueryStargate { + path: "/injective.exchange.v1beta1.Query/QueryExchangeParams".to_string(), + query_request: "".to_string(), + }; + + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + let contract_response = contract_response.value; + println!("{:?}", contract_response); + let response: ParamResponse = from_json(&contract_response).unwrap(); + println!("{:?}", response); + let listing_fee_coin = str_coin("1000", BASE_DENOM, BASE_DECIMALS); + assert_eq!(response.params.spot_market_instant_listing_fee, listing_fee_coin); +} \ No newline at end of file diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs new file mode 100644 index 00000000..39e08406 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs @@ -0,0 +1,19 @@ +use cosmwasm_std::Coin; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct ExchangeParams { + pub spot_market_instant_listing_fee: Coin, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct ParamResponse { + pub params: T, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct AuthParams { + pub max_memo_characters: String, + pub sig_verify_cost_ed25519: String, +} \ No newline at end of file diff --git a/packages/injective-protobuf/src/proto/mod.rs b/packages/injective-protobuf/src/proto/mod.rs index de0fb666..de6005c4 100644 --- a/packages/injective-protobuf/src/proto/mod.rs +++ b/packages/injective-protobuf/src/proto/mod.rs @@ -1,9 +1,9 @@ // @generated -pub mod account; pub mod auth; pub mod coin; pub mod distribution; pub mod exchange; -pub mod oracle; pub mod tx; +pub mod oracle; +pub mod account; From 7295a3109ab6bcd1a430d558dd1d5ead932f6fd1 Mon Sep 17 00:00:00 2001 From: jbernal87 Date: Thu, 25 Apr 2024 05:59:41 +0200 Subject: [PATCH 04/19] add subaccount deposit test --- .../src/contract.rs | 6 +- .../src/msg.rs | 2 +- .../src/testing/test_bank.rs | 8 +- .../src/testing/test_exchange.rs | 99 +++++++++++++++++-- .../src/utils.rs | 9 ++ 5 files changed, 106 insertions(+), 18 deletions(-) diff --git a/contracts/injective-cosmwasm-stargate-example/src/contract.rs b/contracts/injective-cosmwasm-stargate-example/src/contract.rs index f9e66d55..f2fe2284 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/contract.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/contract.rs @@ -7,9 +7,9 @@ use crate::{ }; use cosmwasm_std::{entry_point, Binary, Deps, DepsMut, Env, MessageInfo, Response, StdResult}; use cw2::set_contract_version; -use injective_cosmwasm::{create_deposit_msg, InjectiveMsgWrapper, InjectiveQuerier, InjectiveQueryWrapper}; +use injective_cosmwasm::{create_deposit_msg, InjectiveMsgWrapper, InjectiveQueryWrapper}; -const CONTRACT_NAME: &str = "crates.io:injective:dummy"; +const CONTRACT_NAME: &str = "crates.io:injective:dummy-stargate-contract"; const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION"); pub const CREATE_SPOT_ORDER_REPLY_ID: u64 = 0u64; pub const CREATE_DERIVATIVE_ORDER_REPLY_ID: u64 = 1u64; @@ -23,7 +23,7 @@ pub fn instantiate(deps: DepsMut, _env: Env, _info: MessageInfo, _msg: Instantia #[cfg_attr(not(feature = "library"), entry_point)] pub fn execute( - deps: DepsMut, + _deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, diff --git a/contracts/injective-cosmwasm-stargate-example/src/msg.rs b/contracts/injective-cosmwasm-stargate-example/src/msg.rs index 04d62f34..fffc82de 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/msg.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/msg.rs @@ -2,7 +2,7 @@ use cosmwasm_std::Coin; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use injective_cosmwasm::{CancellationStrategy, MarketId, OracleInfo, OracleType, OrderSide, SubaccountId}; +use injective_cosmwasm::{ SubaccountId}; pub const MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT: &str = "/injective.exchange.v1beta1.MsgCreateSpotLimitOrder"; pub const MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT: &str = "/injective.exchange.v1beta1.MsgCreateDerivativeLimitOrder"; diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs index 1489dc01..118d8b50 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs @@ -17,7 +17,7 @@ use crate::utils::{BASE_DECIMALS, BASE_DENOM, str_coin}; #[test] #[cfg_attr(not(feature = "integration"), ignore)] -fn test_msg_deposit() { +fn test_query_exchange_params() { let env = Setup::new(ExchangeType::None); let wasm = Wasm::new(&env.app); @@ -35,11 +35,7 @@ fn test_msg_deposit() { let contract_response = contract_response.value; let response: ParamResponse = serde_json::from_str(&contract_response).unwrap(); assert_eq!(response.params.max_memo_characters, "256"); - // let response: Value = serde_json::from_str(&contract_response).unwrap(); - // let response = response.as_object().unwrap(); - // println!("{:?}", response); - // assert_eq!(response.get("params").unwrap().as_object().unwrap().get("max_memo_characters").unwrap().as_str().unwrap(), "256"); -} + } diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs index c9da0ea3..182e6b4a 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs @@ -1,10 +1,26 @@ -use cosmwasm_std::{Addr, from_json}; -use injective_test_tube::{Account, Module, Wasm}; -use injective_cosmwasm::checked_address_to_subaccount_id; -use crate::msg::{QueryMsg, QueryStargateResponse}; -use crate::testing::type_helpers::ParamResponse; -use crate::testing::type_helpers::ExchangeParams; -use crate::utils::{BASE_DECIMALS, BASE_DENOM, ExchangeType, Setup, str_coin}; +use base64::{encode, Engine}; +use base64::prelude::BASE64_STANDARD; +use crate::{ + msg::{QueryStargateResponse, QueryMsg}, + utils::{ + add_spot_initial_liquidity, add_spot_order_as, add_spot_orders, dec_to_proto, execute_all_authorizations, + get_initial_liquidity_orders_vector, get_spot_market_id, human_to_dec, human_to_proto, scale_price_quantity_for_spot_market, + scale_price_quantity_for_spot_market_dec, str_coin, ExchangeType, HumanOrder, Setup, BASE_DECIMALS, BASE_DENOM, QUOTE_DECIMALS, QUOTE_DENOM, + }, + testing::type_helpers::{ParamResponse, ExchangeParams}, +}; + +use injective_std::types::injective::exchange::v1beta1::{Deposit, MsgDeposit, MsgInstantSpotMarketLaunch, OrderType, QueryAggregateMarketVolumeResponse, QuerySubaccountDepositRequest, QuerySubaccountDepositResponse, QuerySubaccountDepositsRequest}; + +use cosmwasm_std::{Addr, from_json, to_json_string}; +use injective_test_tube::{injective_cosmwasm::get_default_subaccount_id_for_checked_address, Account, Exchange, Module, RunnerResult, Wasm}; +use injective_cosmwasm::{checked_address_to_subaccount_id, SubaccountDepositResponse, SubaccountId}; +use prost::Message; +use serde_json::to_vec; +use injective_std::types::injective::oracle::v1beta1::GrantPriceFeederPrivilegeProposal; +use crate::order_management::encode_bytes_message; +use crate::testing::type_helpers::AuthParams; +use crate::utils::encode_proto_message; #[test] #[cfg_attr(not(feature = "integration"), ignore)] @@ -29,4 +45,71 @@ fn test_exchange_param() { println!("{:?}", response); let listing_fee_coin = str_coin("1000", BASE_DENOM, BASE_DECIMALS); assert_eq!(response.params.spot_market_instant_listing_fee, listing_fee_coin); -} \ No newline at end of file +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_subaccount_deposit() { + let env = Setup::new(ExchangeType::None); + let exchange = Exchange::new(&env.app); + let wasm = Wasm::new(&env.app); + + let subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(env.users[0].account.address()), 1u32); + + let make_deposit = |amount: &str, denom_key: &str| { + exchange + .deposit( + MsgDeposit { + sender: env.users[0].account.address(), + subaccount_id: subaccount_id.to_string(), + amount: Some(injective_std::types::cosmos::base::v1beta1::Coin { + amount: amount.to_string(), + denom: env.denoms[denom_key].clone(), + }), + }, + &env.users[0].account, + ) + .unwrap(); + }; + + make_deposit("10000000000000000000", "base"); + make_deposit("100000000", "quote"); + + let response = exchange + .query_subaccount_deposits(&QuerySubaccountDepositsRequest { + subaccount_id: subaccount_id.to_string(), + subaccount: None, + }) + .unwrap(); + + assert_eq!( + response.deposits[&env.denoms["base"].clone()], + Deposit { + available_balance: human_to_proto("10.0", BASE_DECIMALS), + total_balance: human_to_proto("10.0", BASE_DECIMALS), + } + ); + assert_eq!( + response.deposits[&env.denoms["quote"].clone()], + Deposit { + available_balance: human_to_proto("100.0", QUOTE_DECIMALS), + total_balance: human_to_proto("100.0", QUOTE_DECIMALS), + } + ); + + + let query_msg = QueryMsg::QueryStargate { + path: "/injective.exchange.v1beta1.Query/SubaccountDeposit".to_string(), + query_request: encode_proto_message(QuerySubaccountDepositRequest { + subaccount_id: subaccount_id.to_string(), + denom: env.denoms["base"].clone(), + }), + }; + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + let contract_response = contract_response.value; + let contract_response: SubaccountDepositResponse = serde_json::from_str(&contract_response).unwrap(); + println!("{:?}", contract_response); + let deposit = contract_response.deposits; + assert_eq!(deposit.total_balance, human_to_dec("10.0", BASE_DECIMALS)); +} + diff --git a/contracts/injective-cosmwasm-stargate-example/src/utils.rs b/contracts/injective-cosmwasm-stargate-example/src/utils.rs index 9b5eaf92..bb9c5888 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/utils.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/utils.rs @@ -33,6 +33,8 @@ use injective_test_tube::{ use injective_testing::human_to_i64; use prost::Message; use std::{collections::HashMap, ops::Neg, str::FromStr}; +use base64::Engine; +use base64::prelude::BASE64_STANDARD; pub const EXCHANGE_DECIMALS: i32 = 18i32; pub const BASE_DECIMALS: i32 = 18i32; @@ -831,3 +833,10 @@ pub fn create_some_usdt_price_attestation(human_price: &str, decimal_precision: publish_time, } } + + +pub fn encode_proto_message(msg: T) -> String { + let mut buf = vec![]; + T::encode(&msg, &mut buf).unwrap(); + BASE64_STANDARD.encode(&buf) +} \ No newline at end of file From 1585aa2a1e1714115d2f68a2829adb2213187b0e Mon Sep 17 00:00:00 2001 From: Markus Waas Date: Fri, 26 Apr 2024 15:36:26 +0200 Subject: [PATCH 05/19] test: add auction tests and some clean ups --- Cargo.lock | 152 ++---------------- contracts/injective-cosmwasm-mock/Cargo.toml | 22 ++- .../Cargo.toml | 24 ++- .../src/contract.rs | 8 +- .../src/msg.rs | 12 +- .../src/query.rs | 35 ++-- .../src/testing/mod.rs | 1 + .../src/testing/test_auction.rs | 102 ++++++++++++ .../src/testing/test_bank.rs | 34 +--- .../src/testing/test_exchange.rs | 40 ++--- 10 files changed, 173 insertions(+), 257 deletions(-) create mode 100644 contracts/injective-cosmwasm-stargate-example/src/testing/test_auction.rs diff --git a/Cargo.lock b/Cargo.lock index e552a8e7..5dd7d243 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -199,8 +199,6 @@ dependencies = [ "bs58", "hmac", "k256 0.13.2", - "once_cell", - "pbkdf2", "rand_core 0.6.4", "ripemd", "sha2 0.10.8", @@ -378,17 +376,6 @@ version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" -[[package]] -name = "cosmos-sdk-proto" -version = "0.19.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73c9d2043a9e617b0d602fbc0a0ecd621568edbf3a9774890a6d562389bd8e1c" -dependencies = [ - "prost 0.11.9", - "prost-types 0.11.9", - "tendermint-proto 0.32.2", -] - [[package]] name = "cosmos-sdk-proto" version = "0.20.0" @@ -400,26 +387,6 @@ dependencies = [ "tendermint-proto 0.34.1", ] -[[package]] -name = "cosmrs" -version = "0.14.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af13955d6f356272e6def9ff5e2450a7650df536d8934f47052a20c76513d2f6" -dependencies = [ - "bip32", - "cosmos-sdk-proto 0.19.0", - "ecdsa 0.16.9", - "eyre", - "getrandom", - "k256 0.13.2", - "rand_core 0.6.4", - "serde 1.0.197", - "serde_json 1.0.111", - "subtle-encoding", - "tendermint 0.32.2", - "thiserror", -] - [[package]] name = "cosmrs" version = "0.15.0" @@ -427,7 +394,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47126f5364df9387b9d8559dcef62e99010e1d4098f39eb3f7ee4b5c254e40ea" dependencies = [ "bip32", - "cosmos-sdk-proto 0.20.0", + "cosmos-sdk-proto", "ecdsa 0.16.9", "eyre", "k256 0.13.2", @@ -436,7 +403,7 @@ dependencies = [ "serde_json 1.0.111", "signature 2.2.0", "subtle-encoding", - "tendermint 0.34.1", + "tendermint", "tendermint-rpc", "thiserror", ] @@ -1513,7 +1480,7 @@ dependencies = [ name = "injective-cosmwasm-mock" version = "1.0.0" dependencies = [ - "cosmos-sdk-proto 0.20.0", + "cosmos-sdk-proto", "cosmwasm-schema", "cosmwasm-std", "cw-storage-plus 1.2.0", @@ -1521,10 +1488,10 @@ dependencies = [ "injective-cosmwasm 0.2.22", "injective-math 0.2.4", "injective-protobuf", - "injective-std 0.1.5", - "injective-test-tube 1.1.7", + "injective-std", + "injective-test-tube", "injective-testing 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", - "prost 0.11.9", + "prost 0.12.3", "protobuf 3.4.0", "schemars", "serde 1.0.197", @@ -1536,7 +1503,7 @@ name = "injective-cosmwasm-stargate-example" version = "0.0.1" dependencies = [ "base64 0.21.5", - "cosmos-sdk-proto 0.20.0", + "cosmos-sdk-proto", "cosmwasm-schema", "cosmwasm-std", "cw-storage-plus 1.2.0", @@ -1544,8 +1511,8 @@ dependencies = [ "injective-cosmwasm 0.2.22", "injective-math 0.2.4", "injective-protobuf", - "injective-std 0.1.6", - "injective-test-tube 1.1.8", + "injective-std", + "injective-test-tube", "injective-testing 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", "prost 0.12.3", "protobuf 3.4.0", @@ -1597,29 +1564,13 @@ dependencies = [ "subtle-encoding", ] -[[package]] -name = "injective-std" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd7a5b52d19dca05823c7e4b481d41b49c04a0e56f66a5c92396a6fdd3314710" -dependencies = [ - "chrono", - "cosmwasm-std", - "osmosis-std-derive 0.15.3", - "prost 0.11.9", - "prost-types 0.11.9", - "schemars", - "serde 1.0.197", - "serde-cw-value", -] - [[package]] name = "injective-std" version = "0.1.6" dependencies = [ "chrono", "cosmwasm-std", - "osmosis-std-derive 0.20.1", + "osmosis-std-derive", "prost 0.12.3", "prost-types 0.12.3", "schemars", @@ -1627,37 +1578,17 @@ dependencies = [ "serde-cw-value", ] -[[package]] -name = "injective-test-tube" -version = "1.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61cb772fd4c8c1da872b742633e73928cbf1cf0505a09ec8ad41934a4d7f10b4" -dependencies = [ - "base64 0.13.1", - "bindgen", - "cosmrs 0.14.0", - "cosmwasm-std", - "hex", - "injective-cosmwasm 0.2.18", - "injective-std 0.1.5", - "prost 0.11.9", - "serde 1.0.197", - "serde_json 1.0.111", - "test-tube-inj", - "thiserror", -] - [[package]] name = "injective-test-tube" version = "1.1.8" dependencies = [ "base64 0.21.5", "bindgen", - "cosmrs 0.15.0", + "cosmrs", "cosmwasm-std", "hex", "injective-cosmwasm 0.2.18", - "injective-std 0.1.6", + "injective-std", "prost 0.12.3", "serde 1.0.197", "serde_json 1.0.111", @@ -2033,18 +1964,6 @@ version = "6.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e2355d85b9a3786f481747ced0e0ff2ba35213a1f9bd406ed906554d7af805a1" -[[package]] -name = "osmosis-std-derive" -version = "0.15.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f4d482a16be198ee04e0f94e10dd9b8d02332dcf33bc5ea4b255e7e25eedc5df" -dependencies = [ - "itertools", - "proc-macro2", - "quote", - "syn 1.0.109", -] - [[package]] name = "osmosis-std-derive" version = "0.20.1" @@ -2064,16 +1983,6 @@ version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c" -[[package]] -name = "pbkdf2" -version = "0.12.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2" -dependencies = [ - "digest 0.10.7", - "hmac", -] - [[package]] name = "peeking_take_while" version = "0.1.2" @@ -3083,37 +2992,6 @@ dependencies = [ "libc", ] -[[package]] -name = "tendermint" -version = "0.32.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f0a7d05cf78524782337f8edd55cbc578d159a16ad4affe2135c92f7dbac7f0" -dependencies = [ - "bytes", - "digest 0.10.7", - "ed25519", - "ed25519-consensus", - "flex-error", - "futures", - "k256 0.13.2", - "num-traits", - "once_cell", - "prost 0.11.9", - "prost-types 0.11.9", - "ripemd", - "serde 1.0.197", - "serde_bytes", - "serde_json 1.0.111", - "serde_repr", - "sha2 0.10.8", - "signature 2.2.0", - "subtle", - "subtle-encoding", - "tendermint-proto 0.32.2", - "time", - "zeroize", -] - [[package]] name = "tendermint" version = "0.34.1" @@ -3154,7 +3032,7 @@ dependencies = [ "flex-error", "serde 1.0.197", "serde_json 1.0.111", - "tendermint 0.34.1", + "tendermint", "toml", "url", ] @@ -3216,7 +3094,7 @@ dependencies = [ "serde_json 1.0.111", "subtle", "subtle-encoding", - "tendermint 0.34.1", + "tendermint", "tendermint-config", "tendermint-proto 0.34.1", "thiserror", @@ -3244,7 +3122,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "751b40929081e03c825df424a5a81645f2cea444654d96f0aad962f7be4e541e" dependencies = [ "base64 0.21.5", - "cosmrs 0.15.0", + "cosmrs", "cosmwasm-std", "prost 0.12.3", "serde 1.0.197", diff --git a/contracts/injective-cosmwasm-mock/Cargo.toml b/contracts/injective-cosmwasm-mock/Cargo.toml index 9b9a55ad..c1343a2f 100644 --- a/contracts/injective-cosmwasm-mock/Cargo.toml +++ b/contracts/injective-cosmwasm-mock/Cargo.toml @@ -19,8 +19,8 @@ crate-type = [ "cdylib", "rlib" ] # for more explicit tests, cargo test --features=backtraces backtraces = [ "cosmwasm-std/backtraces" ] # use library feature to disable all instantiate/execute/query exports -library = [ ] integration = [ ] +library = [ ] [package.metadata.scripts] optimize = """docker run --rm -v "$(pwd)":/code \ @@ -30,24 +30,22 @@ optimize = """docker run --rm -v "$(pwd)":/code \ """ [dependencies] +cosmos-sdk-proto = { version = "0.20.0", default-features = false } +cosmwasm-schema = { version = "1.5.0" } cosmwasm-std = { version = "1.5.0", features = [ "abort", "cosmwasm_1_2", "cosmwasm_1_3", "cosmwasm_1_4", "iterator", "stargate" ] } cw-storage-plus = { version = "1.2.0" } cw2 = { version = "0.16.0" } injective-cosmwasm = { path = "../../packages/injective-cosmwasm" } injective-math = { path = "../../packages/injective-math" } -injective-protobuf = { path = "../../packages/injective-protobuf"} -schemars = { version ="0.8.16"} +injective-protobuf = { path = "../../packages/injective-protobuf" } +injective-std = { path = "../../packages/injective-std" } +prost = { version = "0.12.3" } +protobuf = { version = "3.3.0" } +schemars = { version = "0.8.16" } serde = { version = "1.0.196", default-features = false, features = [ "derive" ] } thiserror = { version = "1.0.56" } -protobuf = { version = "3.3.0" } -prost = { version = "0.11.9" } -injective-std = { version = "0.1.5" } -cosmos-sdk-proto = { version = "0.20.0", default-features = false } -cosmwasm-schema = { version = "1.5.0" } - - [dev-dependencies] -injective-test-tube = { version = "1.1.7" } -injective-std = { version = "0.1.5" } +injective-std = { path = "../../packages/injective-std" } +injective-test-tube = { path = "/Users/markuswaas/work/injective/test-tube/packages/injective-test-tube" } injective-testing = { version = "0.1.6" } diff --git a/contracts/injective-cosmwasm-stargate-example/Cargo.toml b/contracts/injective-cosmwasm-stargate-example/Cargo.toml index 90fb7b76..ca7eaa6e 100644 --- a/contracts/injective-cosmwasm-stargate-example/Cargo.toml +++ b/contracts/injective-cosmwasm-stargate-example/Cargo.toml @@ -19,8 +19,8 @@ crate-type = [ "cdylib", "rlib" ] # for more explicit tests, cargo test --features=backtraces backtraces = [ "cosmwasm-std/backtraces" ] # use library feature to disable all instantiate/execute/query exports -library = [ ] integration = [ ] +library = [ ] [package.metadata.scripts] optimize = """docker run --rm -v "$(pwd)":/code \ @@ -30,26 +30,24 @@ optimize = """docker run --rm -v "$(pwd)":/code \ """ [dependencies] +base64 = "0.21.5" +cosmos-sdk-proto = { version = "0.20.0", default-features = false } +cosmwasm-schema = { version = "1.5.0" } cosmwasm-std = { version = "1.5.0", features = [ "abort", "cosmwasm_1_2", "cosmwasm_1_3", "cosmwasm_1_4", "iterator", "stargate" ] } cw-storage-plus = { version = "1.2.0" } cw2 = { version = "0.16.0" } injective-cosmwasm = { path = "../../packages/injective-cosmwasm" } injective-math = { path = "../../packages/injective-math" } -injective-protobuf = { path = "../../packages/injective-protobuf"} -schemars = { version ="0.8.16"} +injective-protobuf = { path = "../../packages/injective-protobuf" } +injective-std = { path = "../../packages/injective-std" } +prost = { version = "0.12.3" } +protobuf = { version = "3.3.0" } +schemars = { version = "0.8.16" } serde = { version = "1.0.196", default-features = false, features = [ "derive" ] } +serde_json = "1.0.111" thiserror = { version = "1.0.56" } -protobuf = { version = "3.3.0" } -prost = { version = "0.12.3" } -injective-std = { path = "../../packages/injective-std" } -cosmos-sdk-proto = { version = "0.20.0", default-features = false } -cosmwasm-schema = { version = "1.5.0" } -base64 = "0.21.5" -serde_json = "1.0.111" - - [dev-dependencies] -injective-test-tube = { path = "/home/jose/RustroverProjects/test-tube/packages/injective-test-tube" } injective-std = { path = "../../packages/injective-std" } +injective-test-tube = { path = "/Users/markuswaas/work/injective/test-tube/packages/injective-test-tube" } injective-testing = { version = "0.1.6" } diff --git a/contracts/injective-cosmwasm-stargate-example/src/contract.rs b/contracts/injective-cosmwasm-stargate-example/src/contract.rs index f2fe2284..e946085d 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/contract.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/contract.rs @@ -1,9 +1,7 @@ use crate::{ error::ContractError, msg::{ExecuteMsg, InstantiateMsg, QueryMsg}, - query::{ - handle_query_stargate, - }, + query::handle_query_stargate, }; use cosmwasm_std::{entry_point, Binary, Deps, DepsMut, Env, MessageInfo, Response, StdResult}; use cw2::set_contract_version; @@ -25,7 +23,7 @@ pub fn instantiate(deps: DepsMut, _env: Env, _info: MessageInfo, _msg: Instantia pub fn execute( _deps: DepsMut, env: Env, - info: MessageInfo, + _info: MessageInfo, msg: ExecuteMsg, ) -> Result, ContractError> { match msg { @@ -41,5 +39,3 @@ pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> Std QueryMsg::QueryStargate { path, query_request } => handle_query_stargate(&deps.querier, path, query_request), } } - - diff --git a/contracts/injective-cosmwasm-stargate-example/src/msg.rs b/contracts/injective-cosmwasm-stargate-example/src/msg.rs index fffc82de..56654897 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/msg.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/msg.rs @@ -2,7 +2,7 @@ use cosmwasm_std::Coin; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use injective_cosmwasm::{ SubaccountId}; +use injective_cosmwasm::SubaccountId; pub const MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT: &str = "/injective.exchange.v1beta1.MsgCreateSpotLimitOrder"; pub const MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT: &str = "/injective.exchange.v1beta1.MsgCreateDerivativeLimitOrder"; @@ -13,19 +13,13 @@ pub struct InstantiateMsg {} #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] #[serde(rename_all = "snake_case")] pub enum ExecuteMsg { - TestDepositMsg { - subaccount_id: SubaccountId, - amount: Coin, - }, + TestDepositMsg { subaccount_id: SubaccountId, amount: Coin }, } #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] #[serde(rename_all = "snake_case")] pub enum QueryMsg { - QueryStargate { - path: String, - query_request: String, - }, + QueryStargate { path: String, query_request: String }, } #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] diff --git a/contracts/injective-cosmwasm-stargate-example/src/query.rs b/contracts/injective-cosmwasm-stargate-example/src/query.rs index 19f45ae6..807d27c3 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/query.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/query.rs @@ -1,34 +1,25 @@ -use cosmwasm_std::{to_json_binary, Binary, to_json_vec, ContractResult, StdError, StdResult, SystemResult, QuerierWrapper}; -use injective_cosmwasm::{InjectiveQueryWrapper}; use crate::msg::QueryStargateResponse; use base64::engine::general_purpose::STANDARD as BASE64_STANDARD; use base64::Engine as _; +use cosmwasm_std::{to_json_binary, to_json_vec, Binary, ContractResult, QuerierWrapper, QueryRequest, StdError, StdResult, SystemResult}; +use injective_cosmwasm::InjectiveQueryWrapper; pub fn handle_query_stargate(querier: &QuerierWrapper, path: String, query_request: String) -> StdResult { - let data = Binary::from_base64(&query_request)?; - let request = &cosmwasm_std::QueryRequest::::Stargate { path, data }; - - let raw = to_json_vec(request).map_err(|serialize_err| { - StdError::generic_err(format!("Serializing QueryRequest: {}", serialize_err)) - })?; + let request = &QueryRequest::::Stargate { path, data }; + let raw = to_json_vec(request).map_err(|serialize_err| StdError::generic_err(format!("Serializing QueryRequest: {}", serialize_err)))?; - let value = match querier.raw_query (&raw) { - SystemResult::Err(system_err) => Err(StdError::generic_err(format!( - "Querier system error: {}", - system_err - ))), - SystemResult::Ok(ContractResult::Err(contract_err)) => Err(StdError::generic_err(format!( - "Querier contract error: {}", - contract_err - ))), + let value = match querier.raw_query(&raw) { + SystemResult::Err(system_err) => Err(StdError::generic_err(format!("Querier system error: {}", system_err))), + SystemResult::Ok(ContractResult::Err(contract_err)) => Err(StdError::generic_err(format!("Querier contract error: {}", contract_err))), SystemResult::Ok(ContractResult::Ok(value)) => Ok(value), }? - .to_string(); + .to_string(); let decoded_value = BASE64_STANDARD - .decode(value).map_err(|_| StdError::generic_err("Decoding base64 value"))?; - - to_json_binary(&QueryStargateResponse { value: String::from_utf8(decoded_value)? }) + .decode(value) + .map_err(|_| StdError::generic_err("Decoding base64 value"))?; + to_json_binary(&QueryStargateResponse { + value: String::from_utf8(decoded_value)?, + }) } - diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs index c98a9242..0cbc3926 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs @@ -1,3 +1,4 @@ +mod test_auction; mod test_bank; mod test_exchange; mod type_helpers; diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_auction.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_auction.rs new file mode 100644 index 00000000..fbd7dc38 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_auction.rs @@ -0,0 +1,102 @@ +use cosmwasm_std::{from_json, Coin, Int64, Uint128, Uint64}; +use injective_math::FPDecimal; +use injective_test_tube::{Module, Wasm}; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + +use crate::msg::QueryStargateResponse; +use crate::{ + msg::QueryMsg, + utils::{ExchangeType, Setup}, +}; + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct QueryCurrentAuctionBasketResponse { + pub amount: Vec, + pub auction_round: Uint64, + pub auction_closing_time: Int64, + pub highest_bidder: String, + pub highest_bid_amount: Uint128, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct QueryAuctionParamsResponse { + pub params: AuctionParams, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct AuctionParams { + pub auction_period: Int64, + pub min_next_bid_increment_rate: FPDecimal, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct QueryLastAuctionResultResponse { + pub last_auction_result: LastAuctionResult, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct LastAuctionResult { + pub winner: String, + pub amount: Coin, + pub round: Uint64, +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_current_auction_basket() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + let query_msg = QueryMsg::QueryStargate { + path: "/injective.auction.v1beta1.Query/CurrentAuctionBasket".to_string(), + query_request: "".to_string(), + }; + + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + let contract_response = contract_response.value; + let response: QueryCurrentAuctionBasketResponse = from_json(contract_response).unwrap(); + + assert_eq!(response.amount, vec![]); + assert_eq!(response.auction_closing_time, Int64::from(-62122291200i64)); + assert_eq!(response.highest_bid_amount, Uint128::zero()); + assert_eq!(response.auction_round, Uint64::from(21u64)); + assert_eq!(response.highest_bidder, "".to_string()); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_auction_params() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + let query_msg = QueryMsg::QueryStargate { + path: "/injective.auction.v1beta1.Query/AuctionParams".to_string(), + query_request: "".to_string(), + }; + + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + let contract_response = contract_response.value; + let response: QueryAuctionParamsResponse = from_json(contract_response).unwrap(); + + assert_eq!(response.params.auction_period, Int64::from(604800i64)); + assert_eq!(response.params.min_next_bid_increment_rate, FPDecimal::must_from_str("0.0025")); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_last_auction_result() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + let query_msg = QueryMsg::QueryStargate { + path: "/injective.auction.v1beta1.Query/LastAuctionResult".to_string(), + query_request: "".to_string(), + }; + + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + let contract_response = contract_response.value; + let response: QueryLastAuctionResultResponse = from_json(contract_response).unwrap(); + + assert_eq!(response.last_auction_result.winner, "".to_string()); + assert_eq!(response.last_auction_result.round, Uint64::zero()); + assert_eq!(response.last_auction_result.amount, Coin::new(0, "inj")); +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs index 118d8b50..80d8a046 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs @@ -1,44 +1,22 @@ -use cosmwasm_std::{Addr, from_json, Coin}; -use injective_test_tube::{Account, Module, Wasm}; -use schemars::JsonSchema; -use serde::{Deserialize, Serialize}; -use injective_cosmwasm::{checked_address_to_subaccount_id}; - use crate::{ - msg::QueryMsg, - utils::{ - ExchangeType, Setup, - }, + msg::{QueryMsg, QueryStargateResponse}, + testing::type_helpers::{AuthParams, ParamResponse}, + utils::{ExchangeType, Setup}, }; -use crate::msg::QueryStargateResponse; -use serde_json::{Value, Map}; -use crate::testing::type_helpers::{AuthParams, ParamResponse}; -use crate::utils::{BASE_DECIMALS, BASE_DENOM, str_coin}; +use injective_test_tube::{Module, Wasm}; #[test] #[cfg_attr(not(feature = "integration"), ignore)] fn test_query_exchange_params() { let env = Setup::new(ExchangeType::None); - let wasm = Wasm::new(&env.app); - let user = &env.users[0]; - - let subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(user.account.address()), 1u32); - // Execute contract - let query_msg = QueryMsg::QueryStargate { path: "/cosmos.auth.v1beta1.Query/Params".to_string(), query_request: "".to_string(), }; let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); - let contract_response = contract_response.value; + let contract_response = contract_response.value; let response: ParamResponse = serde_json::from_str(&contract_response).unwrap(); assert_eq!(response.params.max_memo_characters, "256"); - } - - - - - - +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs index 182e6b4a..70de30d6 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs @@ -1,37 +1,19 @@ -use base64::{encode, Engine}; -use base64::prelude::BASE64_STANDARD; +use crate::utils::encode_proto_message; use crate::{ - msg::{QueryStargateResponse, QueryMsg}, - utils::{ - add_spot_initial_liquidity, add_spot_order_as, add_spot_orders, dec_to_proto, execute_all_authorizations, - get_initial_liquidity_orders_vector, get_spot_market_id, human_to_dec, human_to_proto, scale_price_quantity_for_spot_market, - scale_price_quantity_for_spot_market_dec, str_coin, ExchangeType, HumanOrder, Setup, BASE_DECIMALS, BASE_DENOM, QUOTE_DECIMALS, QUOTE_DENOM, - }, - testing::type_helpers::{ParamResponse, ExchangeParams}, + msg::{QueryMsg, QueryStargateResponse}, + testing::type_helpers::{ExchangeParams, ParamResponse}, + utils::{human_to_dec, human_to_proto, str_coin, ExchangeType, Setup, BASE_DECIMALS, BASE_DENOM, QUOTE_DECIMALS}, }; - -use injective_std::types::injective::exchange::v1beta1::{Deposit, MsgDeposit, MsgInstantSpotMarketLaunch, OrderType, QueryAggregateMarketVolumeResponse, QuerySubaccountDepositRequest, QuerySubaccountDepositResponse, QuerySubaccountDepositsRequest}; - -use cosmwasm_std::{Addr, from_json, to_json_string}; -use injective_test_tube::{injective_cosmwasm::get_default_subaccount_id_for_checked_address, Account, Exchange, Module, RunnerResult, Wasm}; -use injective_cosmwasm::{checked_address_to_subaccount_id, SubaccountDepositResponse, SubaccountId}; -use prost::Message; -use serde_json::to_vec; -use injective_std::types::injective::oracle::v1beta1::GrantPriceFeederPrivilegeProposal; -use crate::order_management::encode_bytes_message; -use crate::testing::type_helpers::AuthParams; -use crate::utils::encode_proto_message; +use cosmwasm_std::{from_json, Addr}; +use injective_cosmwasm::{checked_address_to_subaccount_id, SubaccountDepositResponse}; +use injective_std::types::injective::exchange::v1beta1::{Deposit, MsgDeposit, QuerySubaccountDepositRequest, QuerySubaccountDepositsRequest}; +use injective_test_tube::{Account, Exchange, Module, Wasm}; #[test] #[cfg_attr(not(feature = "integration"), ignore)] fn test_exchange_param() { let env = Setup::new(ExchangeType::None); - let wasm = Wasm::new(&env.app); - let user = &env.users[0]; - - let subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(user.account.address()), 1u32); - // Execute contract let query_msg = QueryMsg::QueryStargate { path: "/injective.exchange.v1beta1.Query/QueryExchangeParams".to_string(), @@ -39,7 +21,7 @@ fn test_exchange_param() { }; let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); - let contract_response = contract_response.value; + let contract_response = contract_response.value; println!("{:?}", contract_response); let response: ParamResponse = from_json(&contract_response).unwrap(); println!("{:?}", response); @@ -97,7 +79,6 @@ fn test_query_subaccount_deposit() { } ); - let query_msg = QueryMsg::QueryStargate { path: "/injective.exchange.v1beta1.Query/SubaccountDeposit".to_string(), query_request: encode_proto_message(QuerySubaccountDepositRequest { @@ -106,10 +87,9 @@ fn test_query_subaccount_deposit() { }), }; let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); - let contract_response = contract_response.value; + let contract_response = contract_response.value; let contract_response: SubaccountDepositResponse = serde_json::from_str(&contract_response).unwrap(); println!("{:?}", contract_response); let deposit = contract_response.deposits; assert_eq!(deposit.total_balance, human_to_dec("10.0", BASE_DECIMALS)); } - From b657d5dab71e8015d686331eaa7353a5fbee1569 Mon Sep 17 00:00:00 2001 From: jbernal87 Date: Thu, 25 Apr 2024 13:57:21 +0200 Subject: [PATCH 06/19] complete stargate queries --- .../src/contract.rs | 36 +- .../src/encode_helper.rs | 9 + .../src/handle.rs | 113 ++++++ .../src/lib.rs | 3 + .../src/msg.rs | 17 +- .../src/reply.rs | 82 ++++ .../src/state.rs | 2 +- .../src/testing/mod.rs | 3 + .../src/testing/test_auth.rs | 44 ++ .../src/testing/test_bank.rs | 91 ++++- .../src/testing/test_exchange.rs | 51 ++- .../src/testing/test_exchange_derivative.rs | 384 ++++++++++++++++++ .../src/testing/test_oracle.rs | 123 ++++++ .../src/testing/type_helpers.rs | 219 +++++++++- .../src/utils.rs | 22 +- .../src/exchange/spot_market.rs | 1 + .../src/exchange_mock_querier.rs | 1 + .../injective-cosmwasm/src/test_helpers.rs | 1 + .../src/types/injective/exchange/v1beta1.rs | 6 + 19 files changed, 1174 insertions(+), 34 deletions(-) create mode 100644 contracts/injective-cosmwasm-stargate-example/src/encode_helper.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/reply.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/testing/test_auth.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange_derivative.rs create mode 100644 contracts/injective-cosmwasm-stargate-example/src/testing/test_oracle.rs diff --git a/contracts/injective-cosmwasm-stargate-example/src/contract.rs b/contracts/injective-cosmwasm-stargate-example/src/contract.rs index e946085d..aec4b87a 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/contract.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/contract.rs @@ -1,17 +1,18 @@ use crate::{ error::ContractError, + handle::{handle_test_transient_derivative_order, handle_test_transient_spot_order}, msg::{ExecuteMsg, InstantiateMsg, QueryMsg}, query::handle_query_stargate, + reply::{handle_create_derivative_order_reply_stargate, handle_create_order_reply_stargate}, }; -use cosmwasm_std::{entry_point, Binary, Deps, DepsMut, Env, MessageInfo, Response, StdResult}; +use cosmwasm_std::{entry_point, Binary, Deps, DepsMut, Env, MessageInfo, Reply, Response, StdResult}; use cw2::set_contract_version; -use injective_cosmwasm::{create_deposit_msg, InjectiveMsgWrapper, InjectiveQueryWrapper}; +use injective_cosmwasm::{InjectiveMsgWrapper, InjectiveQueryWrapper}; const CONTRACT_NAME: &str = "crates.io:injective:dummy-stargate-contract"; const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION"); pub const CREATE_SPOT_ORDER_REPLY_ID: u64 = 0u64; pub const CREATE_DERIVATIVE_ORDER_REPLY_ID: u64 = 1u64; -pub const MSG_EXEC: &str = "/cosmos.authz.v1beta1.MsgExec"; #[cfg_attr(not(feature = "library"), entry_point)] pub fn instantiate(deps: DepsMut, _env: Env, _info: MessageInfo, _msg: InstantiateMsg) -> Result { @@ -21,15 +22,25 @@ pub fn instantiate(deps: DepsMut, _env: Env, _info: MessageInfo, _msg: Instantia #[cfg_attr(not(feature = "library"), entry_point)] pub fn execute( - _deps: DepsMut, + deps: DepsMut, env: Env, - _info: MessageInfo, + info: MessageInfo, msg: ExecuteMsg, ) -> Result, ContractError> { match msg { - ExecuteMsg::TestDepositMsg { subaccount_id, amount } => { - Ok(Response::new().add_message(create_deposit_msg(env.contract.address, subaccount_id, amount))) - } + ExecuteMsg::TestTraderTransientSpotOrders { + market_id, + subaccount_id, + price, + quantity, + } => handle_test_transient_spot_order(deps, env, &info, market_id, subaccount_id, price, quantity), + ExecuteMsg::TestTraderTransientDerivativeOrders { + market_id, + subaccount_id, + price, + quantity, + margin, + } => handle_test_transient_derivative_order(deps, env, &info, market_id, subaccount_id, price, quantity, margin), } } @@ -39,3 +50,12 @@ pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> Std QueryMsg::QueryStargate { path, query_request } => handle_query_stargate(&deps.querier, path, query_request), } } + +#[cfg_attr(not(feature = "library"), entry_point)] +pub fn reply(deps: DepsMut, _env: Env, msg: Reply) -> Result { + match msg.id { + CREATE_SPOT_ORDER_REPLY_ID => handle_create_order_reply_stargate(deps, &msg), + CREATE_DERIVATIVE_ORDER_REPLY_ID => handle_create_derivative_order_reply_stargate(deps, &msg), + _ => Err(ContractError::UnrecognizedReply(msg.id)), + } +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/encode_helper.rs b/contracts/injective-cosmwasm-stargate-example/src/encode_helper.rs new file mode 100644 index 00000000..b1ea5bc2 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/encode_helper.rs @@ -0,0 +1,9 @@ +use base64::engine::general_purpose::STANDARD as BASE64_STANDARD; +use base64::Engine; +use prost::Message; + +pub fn encode_proto_message(msg: T) -> String { + let mut buf = vec![]; + T::encode(&msg, &mut buf).unwrap(); + BASE64_STANDARD.encode(&buf) +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/handle.rs b/contracts/injective-cosmwasm-stargate-example/src/handle.rs index 8b137891..db93e335 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/handle.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/handle.rs @@ -1 +1,114 @@ +use crate::{ + contract::{CREATE_DERIVATIVE_ORDER_REPLY_ID, CREATE_SPOT_ORDER_REPLY_ID}, + msg::{MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT, MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT}, + order_management::{create_derivative_limit_order, create_spot_limit_order, create_stargate_msg, encode_bytes_message}, + state::{CacheOrderInfo, ORDER_CALL_CACHE}, + ContractError, +}; +use cosmos_sdk_proto::{cosmos::authz::v1beta1::MsgExec, traits::Message, Any}; +use cosmwasm_std::{DepsMut, Env, MessageInfo, Response, SubMsg}; +use injective_cosmwasm::{InjectiveMsgWrapper, InjectiveQuerier, InjectiveQueryWrapper, MarketId, OrderType, SubaccountId}; +use injective_math::{scale::Scaled, FPDecimal}; +pub const MSG_EXEC: &str = "/cosmos.authz.v1beta1.MsgExec"; + +pub fn handle_test_transient_spot_order( + deps: DepsMut, + env: Env, + info: &MessageInfo, + market_id: MarketId, + subaccount_id: SubaccountId, + price: String, + quantity: String, +) -> Result, ContractError> { + let querier = InjectiveQuerier::new(&deps.querier); + let spot_market = querier.query_spot_market(&market_id).unwrap().market.unwrap(); + + let order_msg = create_spot_limit_order( + FPDecimal::must_from_str(price.as_str()).scaled(18i32), + FPDecimal::must_from_str(quantity.as_str()).scaled(18i32), + OrderType::Sell, + info.sender.as_str(), + subaccount_id.as_str(), + &spot_market, + ); + + let order_bytes = encode_bytes_message(&order_msg).unwrap(); + + let msg_exec = MsgExec { + grantee: env.contract.address.to_string(), + msgs: vec![Any { + type_url: MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT.to_string(), + value: order_bytes, + }], + }; + + let order_submessage = SubMsg::reply_on_success( + create_stargate_msg(MSG_EXEC, msg_exec.encode_to_vec()).unwrap(), + CREATE_SPOT_ORDER_REPLY_ID, + ); + + save_cache_info(deps, market_id, subaccount_id)?; + + Ok(Response::new().add_submessage(order_submessage)) +} + +pub fn handle_test_transient_derivative_order( + deps: DepsMut, + env: Env, + info: &MessageInfo, + market_id: MarketId, + subaccount_id: SubaccountId, + price: String, + quantity: String, + margin: String, +) -> Result, ContractError> { + let querier: InjectiveQuerier = InjectiveQuerier::new(&deps.querier); + let market = querier.query_derivative_market(&market_id).unwrap().market.unwrap(); + + let order_msg = create_derivative_limit_order( + FPDecimal::must_from_str(price.as_str()).scaled(18i32), + FPDecimal::must_from_str(quantity.as_str()).scaled(18i32), + FPDecimal::must_from_str(margin.as_str()).scaled(18i32), + OrderType::Buy, + info.sender.as_str(), + subaccount_id.as_str(), + &market, + ); + + let order_bytes = encode_bytes_message(&order_msg).unwrap(); + + let msg_exec = MsgExec { + grantee: env.contract.address.to_string(), + msgs: vec![Any { + type_url: MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT.to_string(), + value: order_bytes, + }], + }; + + let order_submessage = SubMsg::reply_on_success( + create_stargate_msg(MSG_EXEC, msg_exec.encode_to_vec()).unwrap(), + CREATE_DERIVATIVE_ORDER_REPLY_ID, + ); + + save_cache_info(deps, market_id, subaccount_id)?; + + Ok(Response::new().add_submessage(order_submessage)) +} + +fn save_cache_info(deps: DepsMut, market_id: MarketId, subaccount_id: SubaccountId) -> Result<(), ContractError> { + let cache_order_info = CacheOrderInfo { + subaccount: subaccount_id, + market_id, + }; + + let mut order_cache = match ORDER_CALL_CACHE.may_load(deps.storage)? { + Some(order_cache) => order_cache, + None => vec![], + }; + + order_cache.push(cache_order_info); + + ORDER_CALL_CACHE.save(deps.storage, &order_cache)?; + Ok(()) +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/lib.rs b/contracts/injective-cosmwasm-stargate-example/src/lib.rs index 7f92cfb1..44ab7abb 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/lib.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/lib.rs @@ -1,13 +1,16 @@ pub mod contract; +mod encode_helper; mod error; mod handle; pub mod msg; mod order_management; mod query; +mod reply; mod state; #[cfg(test)] mod testing; mod types; #[cfg(test)] pub mod utils; + pub use crate::error::ContractError; diff --git a/contracts/injective-cosmwasm-stargate-example/src/msg.rs b/contracts/injective-cosmwasm-stargate-example/src/msg.rs index 56654897..4efaae39 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/msg.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/msg.rs @@ -1,8 +1,7 @@ -use cosmwasm_std::Coin; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use injective_cosmwasm::SubaccountId; +use injective_cosmwasm::{MarketId, SubaccountId}; pub const MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT: &str = "/injective.exchange.v1beta1.MsgCreateSpotLimitOrder"; pub const MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT: &str = "/injective.exchange.v1beta1.MsgCreateDerivativeLimitOrder"; @@ -13,7 +12,19 @@ pub struct InstantiateMsg {} #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] #[serde(rename_all = "snake_case")] pub enum ExecuteMsg { - TestDepositMsg { subaccount_id: SubaccountId, amount: Coin }, + TestTraderTransientSpotOrders { + market_id: MarketId, + subaccount_id: SubaccountId, + price: String, + quantity: String, + }, + TestTraderTransientDerivativeOrders { + market_id: MarketId, + subaccount_id: SubaccountId, + price: String, + quantity: String, + margin: String, + }, } #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] diff --git a/contracts/injective-cosmwasm-stargate-example/src/reply.rs b/contracts/injective-cosmwasm-stargate-example/src/reply.rs new file mode 100644 index 00000000..02455269 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/reply.rs @@ -0,0 +1,82 @@ +use crate::{encode_helper::encode_proto_message, query::handle_query_stargate, state::ORDER_CALL_CACHE, ContractError}; +use cosmwasm_std::{DepsMut, Event, Reply, Response}; +use injective_cosmwasm::InjectiveQueryWrapper; + +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, Eq, ::prost::Message, ::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)] +pub struct QueryTraderSpotOrdersRequest { + /// Market ID for the market + #[prost(string, tag = "1")] + #[serde(alias = "marketID")] + pub market_id: ::prost::alloc::string::String, + /// SubaccountID of the trader + #[prost(string, tag = "2")] + #[serde(alias = "subaccountID")] + pub subaccount_id: ::prost::alloc::string::String, +} + +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, Eq, ::prost::Message, ::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)] +pub struct QueryTraderDerivativeOrdersRequest { + /// Market ID for the market + #[prost(string, tag = "1")] + #[serde(alias = "marketID")] + pub market_id: ::prost::alloc::string::String, + /// SubaccountID of the trader + #[prost(string, tag = "2")] + #[serde(alias = "subaccountID")] + pub subaccount_id: ::prost::alloc::string::String, +} + +pub fn handle_create_order_reply_stargate(deps: DepsMut, _msg: &Reply) -> Result { + let mut response_str = "Something went wrong".to_string(); + if let Some(mut cache) = ORDER_CALL_CACHE.may_load(deps.storage)? { + if !cache.is_empty() { + let order_info = &cache[0]; + let encode_query_message = encode_proto_message(QueryTraderSpotOrdersRequest { + market_id: order_info.market_id.clone().into(), + subaccount_id: order_info.subaccount.clone().into(), + }); + let stargate_response = handle_query_stargate( + &deps.querier, + "/injective.exchange.v1beta1.Query/TraderSpotTransientOrders".to_string(), + encode_query_message, + ); + response_str = match stargate_response { + Ok(binary) => String::from_utf8(binary.0).unwrap_or_else(|e| format!("Failed to decode binary to string: {:?}", e)), + Err(e) => format!("Error: {:?}", e), + }; + cache.clear(); + ORDER_CALL_CACHE.save(deps.storage, &cache)?; + } + }; + + Ok(Response::new().add_event(Event::new("transient_order").add_attributes([("query_str", response_str)]))) +} + +pub fn handle_create_derivative_order_reply_stargate(deps: DepsMut, _msg: &Reply) -> Result { + let mut response_str = "Something went wrong".to_string(); + + if let Some(mut cache) = ORDER_CALL_CACHE.may_load(deps.storage)? { + if !cache.is_empty() { + let order_info = &cache[0]; + let encode_query_message = encode_proto_message(QueryTraderDerivativeOrdersRequest { + market_id: order_info.market_id.clone().into(), + subaccount_id: order_info.subaccount.clone().into(), + }); + let stargate_response = handle_query_stargate( + &deps.querier, + "/injective.exchange.v1beta1.Query/TraderDerivativeTransientOrders".to_string(), + encode_query_message, + ); + response_str = match stargate_response { + Ok(binary) => String::from_utf8(binary.0).unwrap_or_else(|e| format!("Failed to decode binary to string: {:?}", e)), + Err(e) => format!("Error: {:?}", e), + }; + cache.clear(); + ORDER_CALL_CACHE.save(deps.storage, &cache)?; + } + }; + + Ok(Response::new().add_event(Event::new("transient_derivative_order").add_attributes([("query_str", response_str)]))) +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/state.rs b/contracts/injective-cosmwasm-stargate-example/src/state.rs index 4f4d8280..0107a245 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/state.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/state.rs @@ -2,7 +2,7 @@ use cosmwasm_schema::cw_serde; use cw_storage_plus::Item; use injective_cosmwasm::{MarketId, SubaccountId}; -pub const ORDER_CALL_CACHE: Item> = Item::new("order_call_cache"); +pub const ORDER_CALL_CACHE: Item> = Item::new("order_call_cache_stargate"); #[cw_serde] pub struct CacheOrderInfo { diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs index 0cbc3926..f79a70e5 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs @@ -1,4 +1,7 @@ mod test_auction; +mod test_auth; mod test_bank; mod test_exchange; +mod test_exchange_derivative; +mod test_oracle; mod type_helpers; diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_auth.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_auth.rs new file mode 100644 index 00000000..dc5bf2e0 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_auth.rs @@ -0,0 +1,44 @@ +use crate::{ + encode_helper::encode_proto_message, + msg::{QueryMsg, QueryStargateResponse}, + testing::type_helpers::{AuthParams, CosmosAuthQueryAccountsResponse, ParamResponse}, + utils::{ExchangeType, Setup}, +}; +use cosmos_sdk_proto::cosmos::auth::v1beta1::QueryAccountRequest; +use injective_test_tube::{Account, Module, Wasm}; + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_auth_params() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + let query_msg = QueryMsg::QueryStargate { + path: "/cosmos.auth.v1beta1.Query/Params".to_string(), + query_request: "".to_string(), + }; + + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + let contract_response = contract_response.value; + let response: ParamResponse = serde_json::from_str(&contract_response).unwrap(); + assert_eq!(response.params.max_memo_characters, "256"); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_auth_account() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + + let user_address = env.users[0].account.address().to_string(); + let query_msg = QueryMsg::QueryStargate { + path: "/cosmos.auth.v1beta1.Query/Account".to_string(), + query_request: encode_proto_message(QueryAccountRequest { + address: user_address.to_owned(), + }), + }; + + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + let contract_response = contract_response.value; + let response: CosmosAuthQueryAccountsResponse = serde_json::from_str(&contract_response).unwrap(); + assert_eq!(response.account.base_account.address, user_address); +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs index 80d8a046..3e4280fe 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs @@ -1,22 +1,101 @@ use crate::{ + encode_helper::encode_proto_message, msg::{QueryMsg, QueryStargateResponse}, - testing::type_helpers::{AuthParams, ParamResponse}, + testing::type_helpers::{BankParams, ParamResponse, QueryBalanceResponse, QuerySupplyOffResponse, QueryDenomMetadataResponse}, utils::{ExchangeType, Setup}, }; -use injective_test_tube::{Module, Wasm}; +use cosmos_sdk_proto::cosmos::bank::v1beta1::{QueryBalanceRequest, QueryDenomMetadataRequest, QuerySupplyOfRequest}; +use cosmwasm_std::{Coin, Uint128}; +use injective_test_tube::{Account, Module, TokenFactory, Wasm}; +use injective_std::types::injective::tokenfactory::v1beta1::MsgCreateDenom; #[test] #[cfg_attr(not(feature = "integration"), ignore)] -fn test_query_exchange_params() { +fn test_query_bank_params() { let env = Setup::new(ExchangeType::None); let wasm = Wasm::new(&env.app); let query_msg = QueryMsg::QueryStargate { - path: "/cosmos.auth.v1beta1.Query/Params".to_string(), + path: "/cosmos.bank.v1beta1.Query/Params".to_string(), query_request: "".to_string(), }; let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); let contract_response = contract_response.value; - let response: ParamResponse = serde_json::from_str(&contract_response).unwrap(); - assert_eq!(response.params.max_memo_characters, "256"); + let response: ParamResponse = serde_json::from_str(&contract_response).unwrap(); + assert_eq!(response.params.default_send_enabled, true); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_denom_metadata() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + let token_factory = TokenFactory::new(&env.app); + + let create_denom_msg = MsgCreateDenom { + sender: env.users[0].account.address().to_string(), + subdenom: "cw".to_string(), + }; + + let denom = token_factory.create_denom(create_denom_msg, &env.users[0].account).unwrap(); + let denom_name = denom.data.new_token_denom; + let query_msg = QueryMsg::QueryStargate { + path: "/cosmos.bank.v1beta1.Query/DenomMetadata".to_string(), + query_request: encode_proto_message(QueryDenomMetadataRequest { + denom: denom_name.to_owned(), + }), + }; + + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + let contract_response = contract_response.value; + let response: QueryDenomMetadataResponse = serde_json::from_str(&contract_response).unwrap(); + assert_eq!(response.metadatas[0].denom_units[0].denom, denom_name); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_bank_balance() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + let user_address = env.users[0].account.address().to_string(); + let query_msg = QueryMsg::QueryStargate { + path: "/cosmos.bank.v1beta1.Query/Balance".to_string(), + query_request: encode_proto_message(QueryBalanceRequest { + address: user_address.to_owned(), + denom: "inj".to_string(), + }), + }; + + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + let contract_response = contract_response.value; + let response: QueryBalanceResponse = serde_json::from_str(&contract_response).unwrap(); + assert_eq!( + response.balance, + Coin { + denom: "inj".to_string(), + amount: Uint128::new(1_000_000_000_000_000_000_000_000), + } + ); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_supply_of() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + let query_msg = QueryMsg::QueryStargate { + path: "/cosmos.bank.v1beta1.Query/SupplyOf".to_string(), + query_request: encode_proto_message(QuerySupplyOfRequest { denom: "inj".to_string() }), + }; + + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + let contract_response = contract_response.value; + let response: QuerySupplyOffResponse = serde_json::from_str(&contract_response).unwrap(); + assert_eq!( + response.amount, + Coin { + denom: "inj".to_string(), + amount: Uint128::new(12000003336863671397639633), + } + ); } diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs index 70de30d6..d002291b 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs @@ -1,11 +1,14 @@ -use crate::utils::encode_proto_message; use crate::{ - msg::{QueryMsg, QueryStargateResponse}, + encode_helper::encode_proto_message, + msg::{ExecuteMsg, QueryMsg, QueryStargateResponse}, testing::type_helpers::{ExchangeParams, ParamResponse}, - utils::{human_to_dec, human_to_proto, str_coin, ExchangeType, Setup, BASE_DECIMALS, BASE_DENOM, QUOTE_DECIMALS}, + utils::{ + add_spot_initial_liquidity, execute_all_authorizations, human_to_dec, human_to_proto, scale_price_quantity_for_spot_market_dec, str_coin, + ExchangeType, Setup, BASE_DECIMALS, BASE_DENOM, QUOTE_DECIMALS, + }, }; use cosmwasm_std::{from_json, Addr}; -use injective_cosmwasm::{checked_address_to_subaccount_id, SubaccountDepositResponse}; +use injective_cosmwasm::{checked_address_to_subaccount_id, MarketId, SubaccountDepositResponse}; use injective_std::types::injective::exchange::v1beta1::{Deposit, MsgDeposit, QuerySubaccountDepositRequest, QuerySubaccountDepositsRequest}; use injective_test_tube::{Account, Exchange, Module, Wasm}; @@ -89,7 +92,45 @@ fn test_query_subaccount_deposit() { let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); let contract_response = contract_response.value; let contract_response: SubaccountDepositResponse = serde_json::from_str(&contract_response).unwrap(); - println!("{:?}", contract_response); let deposit = contract_response.deposits; assert_eq!(deposit.total_balance, human_to_dec("10.0", BASE_DECIMALS)); } + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_trader_transient_spot_orders() { + let env = Setup::new(ExchangeType::Spot); + let wasm = Wasm::new(&env.app); + let market_id = env.market_id.unwrap(); + + let subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(env.users[0].account.address()), 0u32); + + execute_all_authorizations(&env.app, &env.users[0].account, env.contract_address.clone()); + add_spot_initial_liquidity(&env.app, market_id.clone()); + + let (scale_price, scale_quantity) = scale_price_quantity_for_spot_market_dec("9.8", "1", &BASE_DECIMALS, "E_DECIMALS); + + let res = wasm + .execute( + &env.contract_address, + &ExecuteMsg::TestTraderTransientSpotOrders { + market_id: MarketId::new(market_id).unwrap(), + subaccount_id: subaccount_id.clone(), + price: scale_price.to_string(), + quantity: scale_quantity.to_string(), + }, + &[], + &env.users[0].account, + ) + .unwrap(); + + let transient_query = res + .events + .iter() + .find(|e| e.ty == "wasm-transient_order") + .and_then(|event| event.attributes.iter().find(|a| a.key == "query_str")); + + assert!(transient_query.is_some()); + let expected_order_info = "{\"value\":\"{\\\"orders\\\":[{\\\"price\\\":\\\"0.000000000009800000\\\",\\\"quantity\\\":\\\"1000000000000000000.000000000000000000\\\",\\\"fillable\\\":\\\"1000000000000000000.000000000000000000\\\",\\\"isBuy\\\":false,"; + assert!(transient_query.unwrap().value.contains(expected_order_info)); +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange_derivative.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange_derivative.rs new file mode 100644 index 00000000..2db473a4 --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange_derivative.rs @@ -0,0 +1,384 @@ +use crate::{ + encode_helper::encode_proto_message, + msg::{ExecuteMsg, QueryMsg}, + testing::type_helpers::{MyDerivativeMarketResponse, MyPerpetualMarketFundingResponse, MyPerpetualMarketInfoResponse}, + utils::{ + add_derivative_order_as, add_derivative_orders, add_perp_initial_liquidity, dec_to_proto, execute_all_authorizations, + get_initial_perp_liquidity_orders_vector, get_perpetual_market_id, get_stargate_query_result, human_to_dec, scale_price_quantity_perp_market, + scale_price_quantity_perp_market_dec, ExchangeType, HumanOrder, Setup, BASE_DENOM, QUOTE_DECIMALS, QUOTE_DENOM, + }, +}; +use cosmwasm_std::{Addr, Int64}; +use injective_cosmwasm::{ + checked_address_to_subaccount_id, exchange::response::QueryOrderbookResponse, MarketId, MarketMidPriceAndTOBResponse, PriceLevel, + SubaccountEffectivePositionInMarketResponse, SubaccountPositionInMarketResponse, TraderDerivativeOrdersResponse, TrimmedDerivativeLimitOrder, +}; +use injective_math::FPDecimal; +use injective_std::types::injective::exchange::v1beta1::{ + MsgInstantPerpetualMarketLaunch, OrderType, QueryDerivativeMarketRequest, QueryDerivativeMidPriceAndTobRequest, QueryDerivativeOrderbookRequest, + QueryPerpetualMarketFundingRequest, QueryPerpetualMarketInfoRequest, QuerySubaccountEffectivePositionInMarketRequest, + QuerySubaccountPositionInMarketRequest, QueryTraderDerivativeOrdersRequest, +}; +use injective_test_tube::{injective_cosmwasm::get_default_subaccount_id_for_checked_address, Account, Exchange, Module, Wasm}; + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_perpetual_market_info() { + let env = Setup::new(ExchangeType::Derivative); + let wasm = Wasm::new(&env.app); + let exchange = Exchange::new(&env.app); + + let ticker = "INJ/USDT".to_string(); + let derivative_market_id = get_perpetual_market_id(&exchange, ticker.to_owned()); + let market_id = MarketId::new(derivative_market_id.clone()).unwrap(); + + let query_msg = QueryMsg::QueryStargate { + path: "/injective.exchange.v1beta1.Query/PerpetualMarketInfo".to_string(), + query_request: encode_proto_message(QueryPerpetualMarketInfoRequest { + market_id: market_id.to_owned().into(), + }), + }; + + let res = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + assert!(res.info.is_some()); + let market_info = res.info.clone().unwrap(); + assert_eq!(market_info.market_id, market_id); + assert_eq!(market_info.funding_interval, Int64::new(3600)); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_derivative_market() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + let exchange = Exchange::new(&env.app); + let ticker = "INJ/USDT".to_string(); + let initial_margin_ratio = FPDecimal::must_from_str("0.195"); + let maintenance_margin_ratio = FPDecimal::must_from_str("0.05"); + let min_price_tick_size = FPDecimal::must_from_str("1000.0"); + let min_quantity_tick_size = FPDecimal::must_from_str("1000000000000000"); + let min_notional = FPDecimal::must_from_str("1000000000000000"); + + let quote_denom = QUOTE_DENOM.to_string(); + let maker_fee_rate = FPDecimal::ZERO; + let taker_fee_rate = FPDecimal::ZERO; + + exchange + .instant_perpetual_market_launch( + MsgInstantPerpetualMarketLaunch { + sender: env.signer.address(), + ticker: ticker.to_owned(), + quote_denom: quote_denom.to_owned(), + oracle_base: BASE_DENOM.to_owned(), + oracle_quote: quote_denom.to_owned(), + oracle_scale_factor: 6u32, + oracle_type: 2i32, + maker_fee_rate: dec_to_proto(maker_fee_rate).to_string(), + taker_fee_rate: dec_to_proto(taker_fee_rate), + initial_margin_ratio: dec_to_proto(initial_margin_ratio), + maintenance_margin_ratio: dec_to_proto(maintenance_margin_ratio), + min_price_tick_size: dec_to_proto(min_price_tick_size), + min_quantity_tick_size: dec_to_proto(min_quantity_tick_size), + min_notional: dec_to_proto(min_notional), + }, + &env.signer, + ) + .unwrap(); + + let derivative_market_id = get_perpetual_market_id(&exchange, ticker.to_owned()); + let query_msg = QueryMsg::QueryStargate { + path: "/injective.exchange.v1beta1.Query/DerivativeMarket".to_string(), + query_request: encode_proto_message(QueryDerivativeMarketRequest { + market_id: derivative_market_id.to_owned(), + }), + }; + let res = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + + let response_market = res.market.unwrap().market.unwrap(); + assert_eq!(response_market.market_id.as_str(), derivative_market_id); + assert_eq!(response_market.ticker, ticker); + assert_eq!(response_market.quote_denom, quote_denom); + assert_eq!(response_market.min_price_tick_size, min_price_tick_size); + assert_eq!(response_market.min_quantity_tick_size, min_quantity_tick_size); + assert_eq!(response_market.maker_fee_rate, maker_fee_rate); + assert_eq!(response_market.taker_fee_rate, taker_fee_rate); + assert_eq!(response_market.initial_margin_ratio, initial_margin_ratio); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_effective_subaccount_position() { + let env = Setup::new(ExchangeType::Derivative); + let wasm = Wasm::new(&env.app); + let market_id = env.market_id.unwrap(); + + add_perp_initial_liquidity(&env.app, market_id.clone()); + + let (price, quantity, margin) = scale_price_quantity_perp_market("9.7", "1", "2", "E_DECIMALS); + + let subaccount_id = get_default_subaccount_id_for_checked_address(&Addr::unchecked(env.users[1].account.address())) + .as_str() + .to_string(); + + add_derivative_order_as( + &env.app, + market_id.to_owned(), + &env.users[1].account, + price, + quantity, + OrderType::Sell, + margin, + ); + + let query_msg = QueryMsg::QueryStargate { + path: "/injective.exchange.v1beta1.Query/SubaccountEffectivePositionInMarket".to_string(), + query_request: encode_proto_message(QuerySubaccountEffectivePositionInMarketRequest { + market_id: market_id.to_owned(), + subaccount_id: subaccount_id.to_owned(), + }), + }; + + let res = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + assert!(res.state.is_some()); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_vanilla_subaccount_position() { + let env = Setup::new(ExchangeType::Derivative); + let wasm = Wasm::new(&env.app); + let market_id = env.market_id.unwrap(); + + add_perp_initial_liquidity(&env.app, market_id.clone()); + + let (price, quantity, margin) = scale_price_quantity_perp_market("9.7", "1", "2", "E_DECIMALS); + let trader = &env.users[1]; + let subaccount_id = get_default_subaccount_id_for_checked_address(&Addr::unchecked(trader.account.address())) + .as_str() + .to_string(); + + add_derivative_order_as( + &env.app, + market_id.to_owned(), + &env.users[1].account, + price, + quantity, + OrderType::Sell, + margin, + ); + + let query_msg = QueryMsg::QueryStargate { + path: "/injective.exchange.v1beta1.Query/SubaccountPositionInMarket".to_string(), + query_request: encode_proto_message(QuerySubaccountPositionInMarketRequest { + subaccount_id: subaccount_id.to_string(), + market_id: market_id.to_owned(), + }), + }; + + let res: SubaccountPositionInMarketResponse = + get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + println!("{:?}", res); + assert!(res.state.is_some()); + + let liquidity_orders: Vec = vec![HumanOrder { + price: "9.7".to_string(), + quantity: "10".to_string(), + order_type: OrderType::Sell, + }]; + add_derivative_orders(&env.app, market_id.clone(), liquidity_orders.to_owned(), None); + + let res = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + println!("{:?}", res); + assert!(res.state.is_some()); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_trader_derivative_orders() { + let env = Setup::new(ExchangeType::Derivative); + let wasm = Wasm::new(&env.app); + let market_id = env.market_id.unwrap(); + + let (price, quantity, margin) = scale_price_quantity_perp_market("10.1", "1", "2", "E_DECIMALS); + let subaccount_id = get_default_subaccount_id_for_checked_address(&Addr::unchecked(env.users[1].account.address())) + .as_str() + .to_string(); + + add_derivative_order_as( + &env.app, + market_id.to_owned(), + &env.users[1].account, + price, + quantity, + OrderType::Sell, + margin, + ); + + let query_msg = QueryMsg::QueryStargate { + path: "/injective.exchange.v1beta1.Query/TraderDerivativeOrders".to_string(), + query_request: encode_proto_message(QueryTraderDerivativeOrdersRequest { + subaccount_id: subaccount_id.to_string(), + market_id: market_id.to_owned(), + }), + }; + + let res = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + + assert!(res.orders.is_some()); + let orders = res.orders.clone().unwrap(); + assert_eq!(orders.len(), 1); + let expected_order = TrimmedDerivativeLimitOrder { + price: human_to_dec("10.1", QUOTE_DECIMALS), + quantity: FPDecimal::must_from_str("1"), + margin: human_to_dec("20.2", QUOTE_DECIMALS), + fillable: FPDecimal::must_from_str("1"), + isBuy: false, + order_hash: "".to_string(), + }; + assert_eq!(orders[0].price, expected_order.price); + assert_eq!(orders[0].quantity, expected_order.quantity); + assert_eq!(orders[0].fillable, expected_order.fillable); + assert_eq!(orders[0].isBuy, expected_order.isBuy); + assert_eq!(orders[0].margin, expected_order.margin); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_perpetual_market_funding() { + let env = Setup::new(ExchangeType::Derivative); + let wasm = Wasm::new(&env.app); + let exchange = Exchange::new(&env.app); + let ticker = "INJ/USDT".to_string(); + let derivative_market_id = get_perpetual_market_id(&exchange, ticker.to_owned()); + let query_msg = QueryMsg::QueryStargate { + path: "/injective.exchange.v1beta1.Query/PerpetualMarketFunding".to_string(), + query_request: encode_proto_message(QueryPerpetualMarketFundingRequest { + market_id: derivative_market_id.to_owned(), + }), + }; + let res = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + assert!(res.state.is_some()); + let state = res.state.unwrap(); + assert_eq!(state.cumulative_funding, FPDecimal::ZERO); + assert_eq!(state.cumulative_price, FPDecimal::ZERO); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_derivative_market_mid_price_and_tob() { + let env = Setup::new(ExchangeType::Derivative); + let wasm = Wasm::new(&env.app); + let market_id = env.market_id.unwrap(); + + add_perp_initial_liquidity(&env.app, market_id.to_owned()); + let query_msg = QueryMsg::QueryStargate { + path: "/injective.exchange.v1beta1.Query/DerivativeMidPriceAndTOB".to_string(), + query_request: encode_proto_message(QueryDerivativeMidPriceAndTobRequest { + market_id: market_id.to_owned(), + }), + }; + let res = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + assert_eq!(res.mid_price, Some(human_to_dec("10", QUOTE_DECIMALS))); + assert_eq!(res.best_buy_price, Some(human_to_dec("9.9", QUOTE_DECIMALS))); + assert_eq!(res.best_sell_price, Some(human_to_dec("10.1", QUOTE_DECIMALS))); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_derivative_market_orderbook() { + let env = Setup::new(ExchangeType::Derivative); + let wasm = Wasm::new(&env.app); + let market_id = env.market_id.unwrap(); + + let liquidity_orders = get_initial_perp_liquidity_orders_vector(); + add_derivative_orders(&env.app, market_id.clone(), liquidity_orders.to_owned(), None); + + let query_msg = QueryMsg::QueryStargate { + path: "/injective.exchange.v1beta1.Query/DerivativeOrderbook".to_string(), + query_request: encode_proto_message(QueryDerivativeOrderbookRequest { + market_id: market_id.to_owned(), + limit: 0, + limit_cumulative_notional: "100000000000000000000000000000".to_string(), + }), + }; + let res = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + + let buys_price_level = res.buys_price_level; + let sells_price_level = res.sells_price_level; + assert_eq!(buys_price_level.len(), 2); + assert_eq!(sells_price_level.len(), 2); + assert_eq!( + buys_price_level[0], + PriceLevel { + p: human_to_dec(liquidity_orders[2].price.as_str(), QUOTE_DECIMALS), + q: FPDecimal::must_from_str(liquidity_orders[2].quantity.as_str()), + } + ); + assert_eq!( + buys_price_level[1], + PriceLevel { + p: human_to_dec(liquidity_orders[3].price.as_str(), QUOTE_DECIMALS), + q: FPDecimal::must_from_str(liquidity_orders[3].quantity.as_str()), + } + ); + assert_eq!( + sells_price_level[0], + PriceLevel { + p: human_to_dec(liquidity_orders[1].price.as_str(), QUOTE_DECIMALS), + q: FPDecimal::must_from_str(liquidity_orders[1].quantity.as_str()), + } + ); + assert_eq!( + sells_price_level[1], + PriceLevel { + p: human_to_dec(liquidity_orders[0].price.as_str(), QUOTE_DECIMALS), + q: FPDecimal::must_from_str(liquidity_orders[0].quantity.as_str()), + } + ); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_trader_transient_derivative_orders() { + let env = Setup::new(ExchangeType::Derivative); + let wasm = Wasm::new(&env.app); + let market_id = env.market_id.unwrap(); + let subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(env.users[0].account.address()), 0u32); + execute_all_authorizations(&env.app, &env.users[0].account, env.contract_address.clone()); + add_perp_initial_liquidity(&env.app, market_id.clone()); + let (price, quantity, margin) = scale_price_quantity_perp_market("9.7", "0.5", "2", "E_DECIMALS); + add_derivative_order_as( + &env.app, + market_id.to_owned(), + &env.users[0].account, + price, + quantity, + OrderType::Sell, + margin, + ); + let (scale_price, scale_quantity, scaled_margin) = scale_price_quantity_perp_market_dec("9.7", "0.1", "2", "E_DECIMALS); + let res = wasm + .execute( + &env.contract_address, + &ExecuteMsg::TestTraderTransientDerivativeOrders { + market_id: MarketId::new(market_id).unwrap(), + subaccount_id: subaccount_id.clone(), + price: scale_price.to_string(), + quantity: scale_quantity.to_string(), + margin: scaled_margin.to_string(), + }, + &[], + &env.users[0].account, + ) + .unwrap(); + + let transient_query = res + .events + .iter() + .find(|e| e.ty == "wasm-transient_derivative_order") + .and_then(|event| event.attributes.iter().find(|a| a.key == "query_str")); + println!("{:?}", transient_query); + assert!(transient_query.is_some()); + let expected_order_info = "{\"value\":\"{\\\"orders\\\":[{\\\"price\\\":\\\"9700000.000000000000000000\\\",\\\"quantity\\\":\\\"0.100000000000000000\\\",\\\"margin\\\":\\\"1940000.000000000000000000\\\",\\\"fillable\\\":\\\"0.100000000000000000\\\",\\\"isBuy\\\":true,"; + assert!(transient_query.unwrap().value.contains(expected_order_info)); +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_oracle.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_oracle.rs new file mode 100644 index 00000000..c6ebf71c --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_oracle.rs @@ -0,0 +1,123 @@ +use crate::{ + encode_helper::encode_proto_message, + msg::QueryMsg, + testing::type_helpers::{MyOraclePriceResponse, MyPythPriceResponse, MyVolatilityResponse}, + utils::{ + create_some_inj_price_attestation, get_stargate_query_result, relay_pyth_price, set_address_of_pyth_contract, str_coin, ExchangeType, Setup, + BASE_DECIMALS, BASE_DENOM, INJ_PYTH_PRICE_ID, + }, +}; +use injective_cosmwasm::OracleType; +use injective_math::{scale::Scaled, FPDecimal}; +use injective_std::types::injective::oracle::v1beta1::{ + OracleHistoryOptions, OracleInfo, QueryOraclePriceRequest, QueryOracleVolatilityRequest, QueryPythPriceRequest, +}; +use injective_test_tube::{Module, Oracle, Wasm}; + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_oracle_price() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + let oracle = Oracle::new(&env.app); + + let query_msg = QueryMsg::QueryStargate { + path: "/injective.oracle.v1beta1.Query/OraclePrice".to_string(), + query_request: encode_proto_message(QueryOraclePriceRequest { + oracle_type: OracleType::PriceFeed as i32, + base: env.denoms["base"].to_owned(), + quote: env.denoms["quote"].to_owned(), + }), + }; + + let query_oracle_price_request = QueryOraclePriceRequest { + oracle_type: 2i32, + base: env.denoms["base"].to_owned(), + quote: env.denoms["quote"].to_owned(), + }; + + let oracle_response = oracle.query_oracle_price(&query_oracle_price_request); + let contract_response = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + + let oracle_response_pair_state = oracle_response.unwrap().price_pair_state; + let contract_response_pair_state = contract_response.price_pair_state; + + assert!(contract_response_pair_state.is_some()); + assert!(oracle_response_pair_state.is_some()); + let oracle_response_pair_state = oracle_response_pair_state.unwrap(); + let contract_response_pair_state = contract_response_pair_state.unwrap(); + let oracle_response_pair_price = FPDecimal::must_from_str(oracle_response_pair_state.pair_price.as_str()); + assert_eq!(contract_response_pair_state.pair_price.scaled(18), oracle_response_pair_price); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_oracle_volatility() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + + let base_info = Some(OracleInfo { + symbol: env.denoms["base"].to_owned(), + oracle_type: OracleType::PriceFeed as i32, + scale_factor: 6u32, + }); + + let quote_info = Some(OracleInfo { + symbol: env.denoms["quote"].to_owned(), + oracle_type: OracleType::PriceFeed as i32, + scale_factor: 6u32, + }); + + let oracle_history_options = Some(OracleHistoryOptions { + max_age: 60u64, + include_raw_history: true, + include_metadata: true, + }); + + let query_msg = QueryMsg::QueryStargate { + path: "/injective.oracle.v1beta1.Query/OracleVolatility".to_string(), + query_request: encode_proto_message(QueryOracleVolatilityRequest { + base_info, + quote_info, + oracle_history_options, + }), + }; + + let res = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + assert!(res.volatility.is_none()); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_pyth_oracle_price() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + let oracle = Oracle::new(&env.app); + + let validator = env.app.get_first_validator_signing_account(BASE_DENOM.to_string(), 1.2f64).unwrap(); + let pyth_contract = env.app.init_account(&[str_coin("1000000", BASE_DENOM, BASE_DECIMALS)]).unwrap(); + + set_address_of_pyth_contract(&env.app, &validator, &pyth_contract); + let price_attestations = vec![create_some_inj_price_attestation("7", 5, env.app.get_block_time_seconds())]; + relay_pyth_price(&oracle, price_attestations, &pyth_contract); + + let price_pyth_oracle_response = oracle + .query_pyth_price(&QueryPythPriceRequest { + price_id: INJ_PYTH_PRICE_ID.to_string(), + }) + .unwrap(); + let price_pyth_oracle_response = FPDecimal::must_from_str(price_pyth_oracle_response.price_state.unwrap().ema_price.as_str()); + + let query_msg = QueryMsg::QueryStargate { + path: "/injective.oracle.v1beta1.Query/PythPrice".to_string(), + query_request: encode_proto_message(QueryPythPriceRequest { + price_id: INJ_PYTH_PRICE_ID.to_string(), + }), + }; + + let contract_response = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + assert_eq!( + contract_response.price_state.unwrap().ema_price.scaled(BASE_DECIMALS), + price_pyth_oracle_response + ); +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs index 39e08406..f7278c56 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs @@ -1,4 +1,6 @@ -use cosmwasm_std::Coin; +use cosmwasm_std::{Coin, Int64}; +use injective_cosmwasm::MarketId; +use injective_math::FPDecimal; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; @@ -16,4 +18,219 @@ pub struct ParamResponse { pub struct AuthParams { pub max_memo_characters: String, pub sig_verify_cost_ed25519: String, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MySpotMarketResponse { + pub market: Option, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MySpotMarket { + pub ticker: String, + pub base_denom: String, + pub quote_denom: String, + pub maker_fee_rate: FPDecimal, + pub taker_fee_rate: FPDecimal, + pub relayer_fee_share_rate: FPDecimal, + pub market_id: MarketId, + pub status: String, + pub min_price_tick_size: FPDecimal, + pub min_quantity_tick_size: FPDecimal, + pub min_notional: FPDecimal, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MyVolatilityResponse { + pub volatility: Option, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MyPerpetualMarketInfo { + pub market_id: MarketId, + #[serde(default)] + pub hourly_funding_rate_cap: FPDecimal, + #[serde(default)] + pub hourly_interest_rate: FPDecimal, + #[serde(default)] + pub next_funding_timestamp: Int64, + pub funding_interval: Int64, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MyPerpetualMarketInfoResponse { + pub info: Option, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MyDerivativeMarketResponse { + pub market: Option, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MyFullDerivativeMarket { + pub market: Option, + pub mark_price: FPDecimal, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MyDerivativeMarket { + pub ticker: String, + pub oracle_base: String, + pub oracle_quote: String, + #[serde(default)] + pub oracle_type: String, + #[serde(default)] + pub oracle_scale_factor: u32, + pub quote_denom: String, + pub market_id: MarketId, + pub initial_margin_ratio: FPDecimal, + pub maintenance_margin_ratio: FPDecimal, + pub maker_fee_rate: FPDecimal, + pub taker_fee_rate: FPDecimal, + #[serde(rename = "isPerpetual", default)] + pub is_perpetual: bool, + #[serde(default)] + pub min_price_tick_size: FPDecimal, + pub min_quantity_tick_size: FPDecimal, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MyPerpetualMarketFundingResponse { + pub state: Option, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MyPerpetualMarketFunding { + #[serde(default)] + pub cumulative_funding: FPDecimal, + #[serde(default)] + pub cumulative_price: FPDecimal, + #[serde(default)] + pub last_timestamp: Int64, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MyOraclePriceResponse { + pub price_pair_state: Option, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MyPricePairState { + #[serde(default)] + pub pair_price: FPDecimal, + #[serde(default)] + pub base_price: FPDecimal, + #[serde(default)] + pub quote_price: FPDecimal, + #[serde(default)] + pub base_cumulative_price: FPDecimal, + #[serde(default)] + pub quote_cumulative_price: FPDecimal, + #[serde(default)] + pub base_timestamp: Int64, + #[serde(default)] + pub quote_timestamp: Int64, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct MyPythPriceResponse { + pub price_state: Option, +} +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct PythPriceState { + #[serde(default)] + pub price_id: String, + #[serde(default)] + pub ema_price: FPDecimal, + #[serde(default)] + pub ema_conf: FPDecimal, + #[serde(default)] + pub conf: FPDecimal, + #[serde(default)] + pub publish_time: Int64, + pub price_state: PriceState, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct PriceState { + #[serde(default)] + pub price: FPDecimal, + #[serde(default)] + pub cumulative_price: FPDecimal, + #[serde(default)] + pub timestamp: Int64, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct CosmosAuthQueryAccountsResponse { + pub account: AuthAccount, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct AuthAccount { + #[serde(rename = "@type")] + pub type_field: String, + pub base_account: BaseAccount, + pub code_hash: String, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct BaseAccount { + pub address: String, + pub pub_key: Option, + pub account_number: String, + pub sequence: String, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct BankParams { + pub send_enabled: Vec, + pub default_send_enabled: bool, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct SendEnabled { + pub denom: String, + pub enabled: bool, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct QueryBalanceResponse { + pub balance: Coin, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct QuerySupplyOffResponse { + pub amount: Coin, +} + + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct QueryDenomMetadataResponse { + pub metadatas: Vec, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct Metadata { + pub description: String, + pub denom_units: Vec, + pub base: String, + pub display: String, + pub name: String, + pub symbol: String, + pub uri: String, + pub uri_hash: String, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] +pub struct DenomUnit { + pub denom: String, + pub exponent: u32, + pub aliases: Vec, +} + +#[derive(Serialize, Deserialize, Debug)] +pub struct Pagination { + // Define fields based on your pagination structure, if any } \ No newline at end of file diff --git a/contracts/injective-cosmwasm-stargate-example/src/utils.rs b/contracts/injective-cosmwasm-stargate-example/src/utils.rs index bb9c5888..2d65e8ae 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/utils.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/utils.rs @@ -1,4 +1,4 @@ -use crate::msg::{InstantiateMsg, MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT, MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT}; +use crate::msg::{InstantiateMsg, QueryStargateResponse, MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT, MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT}; use cosmwasm_std::{coin, Addr, Coin}; use injective_cosmwasm::{checked_address_to_subaccount_id, SubaccountId}; use injective_math::{scale::Scaled, FPDecimal}; @@ -28,13 +28,12 @@ use injective_std::{ }; use injective_test_tube::{ injective_cosmwasm::get_default_subaccount_id_for_checked_address, Account, Authz, Bank, Exchange, ExecuteResponse, Gov, InjectiveTestApp, - Insurance, Module, Oracle, Runner, SigningAccount, Wasm, + Insurance, Module, Oracle, Runner, RunnerResult, SigningAccount, Wasm, }; use injective_testing::human_to_i64; use prost::Message; +use serde::de::DeserializeOwned; use std::{collections::HashMap, ops::Neg, str::FromStr}; -use base64::Engine; -use base64::prelude::BASE64_STANDARD; pub const EXCHANGE_DECIMALS: i32 = 18i32; pub const BASE_DECIMALS: i32 = 18i32; @@ -328,6 +327,7 @@ pub fn launch_spot_market(exchange: &Exchange, signer: &Signin quote_denom: QUOTE_DENOM.to_string(), min_price_tick_size: dec_to_proto(FPDecimal::must_from_str("0.000000000000001")), min_quantity_tick_size: dec_to_proto(FPDecimal::must_from_str("1")), + min_notional: dec_to_proto(FPDecimal::must_from_str("0.000000000000002")), }, signer, ) @@ -366,6 +366,7 @@ pub fn launch_perp_market(exchange: &Exchange, signer: &Signin maintenance_margin_ratio: "50000000000000000".to_owned(), min_price_tick_size: "1000000000000000000000".to_owned(), min_quantity_tick_size: "1000000000000000".to_owned(), + min_notional: "1000000000000000".to_string(), }, signer, ) @@ -834,9 +835,10 @@ pub fn create_some_usdt_price_attestation(human_price: &str, decimal_precision: } } - -pub fn encode_proto_message(msg: T) -> String { - let mut buf = vec![]; - T::encode(&msg, &mut buf).unwrap(); - BASE64_STANDARD.encode(&buf) -} \ No newline at end of file +pub fn get_stargate_query_result(contract_response: RunnerResult) -> serde_json::Result { + let contract_response = contract_response.unwrap().value; + serde_json::from_str::(&contract_response).map_err(|error| { + println!("{} \n {}", error.to_string(), contract_response); + error + }) +} diff --git a/packages/injective-cosmwasm/src/exchange/spot_market.rs b/packages/injective-cosmwasm/src/exchange/spot_market.rs index 68dc19fb..4b15cd49 100644 --- a/packages/injective-cosmwasm/src/exchange/spot_market.rs +++ b/packages/injective-cosmwasm/src/exchange/spot_market.rs @@ -21,6 +21,7 @@ pub struct SpotMarket { pub status: MarketStatus, pub min_price_tick_size: FPDecimal, pub min_quantity_tick_size: FPDecimal, + pub min_notional: FPDecimal, } impl GenericMarket for SpotMarket { diff --git a/packages/injective-cosmwasm/src/exchange_mock_querier.rs b/packages/injective-cosmwasm/src/exchange_mock_querier.rs index 9d57ae29..ba7762f1 100644 --- a/packages/injective-cosmwasm/src/exchange_mock_querier.rs +++ b/packages/injective-cosmwasm/src/exchange_mock_querier.rs @@ -65,6 +65,7 @@ fn default_spot_market_response_handler(market_id: MarketId) -> QuerierResult { status: MarketStatus::Active, min_price_tick_size: FPDecimal::from_str("0.01").unwrap(), min_quantity_tick_size: FPDecimal::from_str("1000000000000000.0").unwrap(), + min_notional: FPDecimal::from_str("0.01").unwrap(), }), }; SystemResult::Ok(ContractResult::from(to_json_binary(&response))) diff --git a/packages/injective-cosmwasm/src/test_helpers.rs b/packages/injective-cosmwasm/src/test_helpers.rs index 8345e699..36a9af96 100644 --- a/packages/injective-cosmwasm/src/test_helpers.rs +++ b/packages/injective-cosmwasm/src/test_helpers.rs @@ -109,6 +109,7 @@ pub(crate) mod testing_helpers { status: MarketStatus::Active, min_price_tick_size: FPDecimal::from_str("0.01").unwrap(), min_quantity_tick_size: FPDecimal::from_str("0.01").unwrap(), + min_notional: FPDecimal::from_str("0.01").unwrap(), } } } diff --git a/packages/injective-std/src/types/injective/exchange/v1beta1.rs b/packages/injective-std/src/types/injective/exchange/v1beta1.rs index 84143875..e06fcdc3 100644 --- a/packages/injective-std/src/types/injective/exchange/v1beta1.rs +++ b/packages/injective-std/src/types/injective/exchange/v1beta1.rs @@ -1851,6 +1851,10 @@ pub struct MsgInstantSpotMarketLaunch { /// quantity #[prost(string, tag = "6")] pub min_quantity_tick_size: ::prost::alloc::string::String, + // min_notional defines the minimum notional (in quote asset) required for + // orders in the market + #[prost(string, tag = "7")] + pub min_notional: ::prost::alloc::string::String, } /// MsgInstantSpotMarketLaunchResponse defines the Msg/InstantSpotMarketLaunch /// response type. @@ -1916,6 +1920,8 @@ pub struct MsgInstantPerpetualMarketLaunch { /// quantity #[prost(string, tag = "13")] pub min_quantity_tick_size: ::prost::alloc::string::String, + #[prost(string, tag = "14")] + pub min_notional: ::prost::alloc::string::String, } /// MsgInstantPerpetualMarketLaunchResponse defines the /// Msg/InstantPerpetualMarketLaunchResponse response type. From 9d2c6ea5a6052cc5680b1fa8ab1b5e54f8366390 Mon Sep 17 00:00:00 2001 From: jbernal87 Date: Mon, 17 Jun 2024 13:44:12 +0200 Subject: [PATCH 07/19] merge with dev fix --- Cargo.lock | 3916 ----------------- contracts/injective-cosmwasm-mock/Cargo.toml | 4 +- .../Cargo.toml | 6 +- .../src/types/injective/exchange/v1beta1.rs | 4 - 4 files changed, 5 insertions(+), 3925 deletions(-) delete mode 100644 Cargo.lock diff --git a/Cargo.lock b/Cargo.lock deleted file mode 100644 index 5d0a41a7..00000000 --- a/Cargo.lock +++ /dev/null @@ -1,3916 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "addr2line" -version = "0.21.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb" -dependencies = [ - "gimli", -] - -[[package]] -name = "adler" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" - -[[package]] -name = "ahash" -version = "0.7.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9" -dependencies = [ - "getrandom", - "once_cell", - "version_check", -] - -[[package]] -name = "aho-corasick" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" -dependencies = [ - "memchr", -] - -[[package]] -name = "android-tzdata" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0" - -[[package]] -name = "android_system_properties" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" -dependencies = [ - "libc", -] - -[[package]] -name = "anyhow" -version = "1.0.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25bdb32cbbdce2b519a9cd7df3a678443100e265d5e25ca763b7572a5104f5f3" - -[[package]] -name = "arrayvec" -version = "0.3.25" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06f59fe10306bb78facd90d28c2038ad23ffaaefa85bac43c8a434cde383334f" -dependencies = [ - "nodrop", - "odds", -] - -[[package]] -name = "async-trait" -version = "0.1.80" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.64", -] - -[[package]] -name = "atomic-order-example" -version = "0.2.0" -dependencies = [ - "cosmwasm-schema", - "cosmwasm-std", - "cosmwasm-storage", - "cw-multi-test", - "cw-storage-plus 1.2.0", - "cw-utils 0.16.0", - "cw2 0.16.0", - "injective-cosmwasm 0.2.23-rc1", - "injective-math 0.2.4", - "injective-protobuf", - "protobuf 2.28.0", - "schemars", - "serde 1.0.202", - "thiserror", -] - -[[package]] -name = "atty" -version = "0.2.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" -dependencies = [ - "hermit-abi 0.1.19", - "libc", - "winapi", -] - -[[package]] -name = "autocfg" -version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0" - -[[package]] -name = "backtrace" -version = "0.3.71" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d" -dependencies = [ - "addr2line", - "cc", - "cfg-if", - "libc", - "miniz_oxide", - "object", - "rustc-demangle", -] - -[[package]] -name = "base16ct" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "349a06037c7bf932dd7e7d1f653678b2038b9ad46a74102f1fc7bd7872678cce" - -[[package]] -name = "base16ct" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" - -[[package]] -name = "base64" -version = "0.13.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" - -[[package]] -name = "base64" -version = "0.21.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" - -[[package]] -name = "base64ct" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b" - -[[package]] -name = "bech32" -version = "0.9.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d86b93f97252c47b41663388e6d155714a9d0c398b99f1005cbc5f978b29f445" - -[[package]] -name = "bindgen" -version = "0.60.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "062dddbc1ba4aca46de6338e2bf87771414c335f7b2f2036e8f3e9befebf88e6" -dependencies = [ - "bitflags 1.3.2", - "cexpr", - "clang-sys", - "clap", - "env_logger", - "lazy_static", - "lazycell", - "log", - "peeking_take_while", - "proc-macro2", - "quote", - "regex", - "rustc-hash", - "shlex", - "which", -] - -[[package]] -name = "bip32" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e141fb0f8be1c7b45887af94c88b182472b57c96b56773250ae00cd6a14a164" -dependencies = [ - "bs58", - "hmac", -<<<<<<< HEAD - "k256 0.13.2", -======= - "k256 0.13.1", ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 - "rand_core 0.6.4", - "ripemd", - "sha2 0.10.8", - "subtle", - "zeroize", -] - -[[package]] -name = "bitflags" -version = "1.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" - -[[package]] -name = "bitflags" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" - -[[package]] -name = "block-buffer" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4" -dependencies = [ - "generic-array", -] - -[[package]] -name = "block-buffer" -version = "0.10.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" -dependencies = [ - "generic-array", -] - -[[package]] -name = "bnum" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56953345e39537a3e18bdaeba4cb0c58a78c1f61f361dc0fa7c5c7340ae87c5f" - -[[package]] -name = "bs58" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4" -dependencies = [ - "sha2 0.10.8", -] - -[[package]] -name = "bumpalo" -version = "3.16.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" - -[[package]] -name = "byteorder" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" - -[[package]] -name = "bytes" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9" -dependencies = [ - "serde 1.0.202", -] - -[[package]] -name = "cc" -version = "1.0.97" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "099a5357d84c4c61eb35fc8eafa9a79a902c2f76911e5747ced4e032edd8d9b4" - -[[package]] -name = "cexpr" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766" -dependencies = [ - "nom", -] - -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "chrono" -version = "0.4.38" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401" -dependencies = [ - "android-tzdata", - "iana-time-zone", - "js-sys", - "num-traits", - "wasm-bindgen", - "windows-targets 0.52.5", -] - -[[package]] -name = "clang-sys" -version = "1.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67523a3b4be3ce1989d607a828d036249522dd9c1c8de7f4dd2dae43a37369d1" -dependencies = [ - "glob", - "libc", - "libloading", -] - -[[package]] -name = "clap" -version = "3.2.25" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ea181bf566f71cb9a5d17a59e1871af638180a18fb0035c92ae62b705207123" -dependencies = [ - "atty", - "bitflags 1.3.2", - "clap_lex", - "indexmap 1.9.3", - "strsim", - "termcolor", - "textwrap", -] - -[[package]] -name = "clap_lex" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5" -dependencies = [ - "os_str_bytes", -] - -[[package]] -name = "cloudabi" -version = "0.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f" -dependencies = [ - "bitflags 1.3.2", -] - -[[package]] -name = "const-oid" -version = "0.9.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8" - -[[package]] -name = "core-foundation" -version = "0.9.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" -dependencies = [ - "core-foundation-sys", - "libc", -] - -[[package]] -name = "core-foundation-sys" -version = "0.8.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" - -[[package]] -name = "cosmos-sdk-proto" -version = "0.20.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32560304ab4c365791fd307282f76637213d8083c1a98490c35159cd67852237" -dependencies = [ - "prost 0.12.4", - "prost-types 0.12.4", - "tendermint-proto 0.34.1", -] - -[[package]] -name = "cosmrs" -version = "0.15.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47126f5364df9387b9d8559dcef62e99010e1d4098f39eb3f7ee4b5c254e40ea" -dependencies = [ - "bip32", - "cosmos-sdk-proto", - "ecdsa 0.16.9", - "eyre", -<<<<<<< HEAD - "k256 0.13.2", - "rand_core 0.6.4", - "serde 1.0.197", - "serde_json 1.0.111", -======= - "k256 0.13.1", - "rand_core 0.6.4", - "serde 1.0.202", - "serde_json 1.0.117", ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 - "signature 2.2.0", - "subtle-encoding", - "tendermint", - "tendermint-rpc", - "thiserror", -] - -[[package]] -name = "cosmwasm-crypto" -version = "1.5.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd50718a2b6830ce9eb5d465de5a018a12e71729d66b70807ce97e6dd14f931d" -dependencies = [ - "digest 0.10.7", - "ecdsa 0.16.9", - "ed25519-zebra", - "k256 0.13.1", - "rand_core 0.6.4", - "thiserror", -] - -[[package]] -name = "cosmwasm-derive" -version = "1.5.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "242e98e7a231c122e08f300d9db3262d1007b51758a8732cd6210b3e9faa4f3a" -dependencies = [ - "syn 1.0.109", -] - -[[package]] -name = "cosmwasm-schema" -version = "1.5.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7879036156092ad1c22fe0d7316efc5a5eceec2bc3906462a2560215f2a2f929" -dependencies = [ - "cosmwasm-schema-derive", - "schemars", - "serde 1.0.202", - "serde_json 1.0.117", - "thiserror", -] - -[[package]] -name = "cosmwasm-schema-derive" -version = "1.5.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0bb57855fbfc83327f8445ae0d413b1a05ac0d68c396ab4d122b2abd7bb82cb6" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "cosmwasm-std" -version = "1.5.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78c1556156fdf892a55cced6115968b961eaaadd6f724a2c2cb7d1e168e32dd3" -dependencies = [ - "base64 0.21.7", - "bech32", - "bnum", - "cosmwasm-crypto", - "cosmwasm-derive", - "derivative", - "forward_ref", - "hex", - "schemars", - "serde 1.0.202", - "serde-json-wasm 0.5.2", - "sha2 0.10.8", - "static_assertions 1.1.0", - "thiserror", -] - -[[package]] -name = "cosmwasm-storage" -version = "1.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "66de2ab9db04757bcedef2b5984fbe536903ada4a8a9766717a4a71197ef34f6" -dependencies = [ - "cosmwasm-std", - "serde 1.0.202", -] - -[[package]] -name = "cpufeatures" -version = "0.2.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504" -dependencies = [ - "libc", -] - -[[package]] -name = "crunchy" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" - -[[package]] -name = "crypto-bigint" -version = "0.4.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef2b4b23cddf68b89b8f8069890e8c270d54e2d5fe1b143820234805e4cb17ef" -dependencies = [ - "generic-array", - "rand_core 0.6.4", - "subtle", - "zeroize", -] - -[[package]] -name = "crypto-bigint" -version = "0.5.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76" -dependencies = [ - "generic-array", - "rand_core 0.6.4", - "subtle", - "zeroize", -] - -[[package]] -name = "crypto-common" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" -dependencies = [ - "generic-array", - "typenum", -] - -[[package]] -name = "curve25519-dalek" -version = "3.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61" -dependencies = [ - "byteorder", - "digest 0.9.0", - "rand_core 0.5.1", - "subtle", - "zeroize", -] - -[[package]] -name = "curve25519-dalek-ng" -version = "4.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c359b7249347e46fb28804470d071c921156ad62b3eef5d34e2ba867533dec8" -dependencies = [ - "byteorder", - "digest 0.9.0", - "rand_core 0.6.4", - "subtle-ng", - "zeroize", -] - -[[package]] -name = "cw-multi-test" -version = "0.16.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "127c7bb95853b8e828bdab97065c81cb5ddc20f7339180b61b2300565aaa99d1" -dependencies = [ - "anyhow", - "cosmwasm-std", - "cw-storage-plus 1.2.0", - "cw-utils 1.0.3", - "derivative", - "itertools 0.10.5", - "k256 0.11.6", - "prost 0.9.0", - "schemars", - "serde 1.0.202", - "thiserror", -] - -[[package]] -name = "cw-storage-plus" -version = "0.16.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9b6f91c0b94481a3e9ef1ceb183c37d00764f8751e39b45fc09f4d9b970d469" -dependencies = [ - "cosmwasm-std", - "schemars", - "serde 1.0.202", -] - -[[package]] -name = "cw-storage-plus" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d5ff29294ee99373e2cd5fd21786a3c0ced99a52fec2ca347d565489c61b723c" -dependencies = [ - "cosmwasm-std", - "schemars", - "serde 1.0.202", -] - -[[package]] -name = "cw-utils" -version = "0.16.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d6a84c6c1c0acc3616398eba50783934bd6c964bad6974241eaee3460c8f5b26" -dependencies = [ - "cosmwasm-schema", - "cosmwasm-std", - "cw2 0.16.0", - "schemars", - "semver", - "serde 1.0.202", - "thiserror", -] - -[[package]] -name = "cw-utils" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c4a657e5caacc3a0d00ee96ca8618745d050b8f757c709babafb81208d4239c" -dependencies = [ - "cosmwasm-schema", - "cosmwasm-std", - "cw2 1.1.2", - "schemars", - "semver", - "serde 1.0.202", - "thiserror", -] - -[[package]] -name = "cw2" -version = "0.16.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91398113b806f4d2a8d5f8d05684704a20ffd5968bf87e3473e1973710b884ad" -dependencies = [ - "cosmwasm-schema", - "cosmwasm-std", - "cw-storage-plus 0.16.0", - "schemars", - "serde 1.0.202", -] - -[[package]] -name = "cw2" -version = "1.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6c120b24fbbf5c3bedebb97f2cc85fbfa1c3287e09223428e7e597b5293c1fa" -dependencies = [ - "cosmwasm-schema", - "cosmwasm-std", - "cw-storage-plus 1.2.0", - "schemars", - "semver", - "serde 1.0.202", - "thiserror", -] - -[[package]] -name = "darling" -version = "0.20.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83b2eb4d90d12bdda5ed17de686c2acb4c57914f8f921b8da7e112b5a36f3fe1" -dependencies = [ - "darling_core", - "darling_macro", -] - -[[package]] -name = "darling_core" -version = "0.20.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "622687fe0bac72a04e5599029151f5796111b90f1baaa9b544d807a5e31cd120" -dependencies = [ - "fnv", - "ident_case", - "proc-macro2", - "quote", - "syn 2.0.64", -] - -[[package]] -name = "darling_macro" -version = "0.20.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "733cabb43482b1a1b53eee8583c2b9e8684d592215ea83efd305dd31bc2f0178" -dependencies = [ - "darling_core", - "quote", - "syn 2.0.64", -] - -[[package]] -name = "der" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1a467a65c5e759bce6e65eaf91cc29f466cdc57cb65777bd646872a8a1fd4de" -dependencies = [ - "const-oid", - "zeroize", -] - -[[package]] -name = "der" -version = "0.7.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0" -dependencies = [ - "const-oid", - "zeroize", -] - -[[package]] -name = "deranged" -version = "0.3.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4" -dependencies = [ - "powerfmt", -] - -[[package]] -name = "derivative" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "digest" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066" -dependencies = [ - "generic-array", -] - -[[package]] -name = "digest" -version = "0.10.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" -dependencies = [ - "block-buffer 0.10.4", - "const-oid", - "crypto-common", - "subtle", -] - -[[package]] -name = "dummy" -version = "1.1.0" -dependencies = [ - "cosmwasm-std", - "cw-storage-plus 1.2.0", - "cw2 0.16.0", - "injective-cosmwasm 0.2.23-rc1", - "schemars", - "serde 1.0.202", - "thiserror", -] - -[[package]] -name = "dyn-clone" -version = "1.0.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125" - -[[package]] -name = "ecdsa" -version = "0.14.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "413301934810f597c1d19ca71c8710e99a3f1ba28a0d2ebc01551a2daeea3c5c" -dependencies = [ - "der 0.6.1", - "elliptic-curve 0.12.3", - "rfc6979 0.3.1", - "signature 1.6.4", -] - -[[package]] -name = "ecdsa" -version = "0.16.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca" -dependencies = [ - "der 0.7.9", - "digest 0.10.7", - "elliptic-curve 0.13.8", - "rfc6979 0.4.0", - "signature 2.2.0", - "spki 0.7.3", -] - -[[package]] -name = "ed25519" -version = "2.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "115531babc129696a58c64a4fef0a8bf9e9698629fb97e9e40767d235cfbcd53" -dependencies = [ - "pkcs8 0.10.2", - "signature 2.2.0", -] - -[[package]] -name = "ed25519-consensus" -version = "2.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c8465edc8ee7436ffea81d21a019b16676ee3db267aa8d5a8d729581ecf998b" -dependencies = [ - "curve25519-dalek-ng", - "hex", - "rand_core 0.6.4", - "sha2 0.9.9", - "zeroize", -] - -[[package]] -name = "ed25519-zebra" -version = "3.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7c24f403d068ad0b359e577a77f92392118be3f3c927538f2bb544a5ecd828c6" -dependencies = [ - "curve25519-dalek", - "hashbrown 0.12.3", - "hex", - "rand_core 0.6.4", - "serde 1.0.202", - "sha2 0.9.9", - "zeroize", -] - -[[package]] -name = "either" -version = "1.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385b58b" - -[[package]] -name = "elliptic-curve" -version = "0.12.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7bb888ab5300a19b8e5bceef25ac745ad065f3c9f7efc6de1b91958110891d3" -dependencies = [ - "base16ct 0.1.1", - "crypto-bigint 0.4.9", - "der 0.6.1", - "digest 0.10.7", - "ff 0.12.1", - "generic-array", - "group 0.12.1", - "pkcs8 0.9.0", - "rand_core 0.6.4", - "sec1 0.3.0", - "subtle", - "zeroize", -] - -[[package]] -name = "elliptic-curve" -version = "0.13.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47" -dependencies = [ - "base16ct 0.2.0", - "crypto-bigint 0.5.5", - "digest 0.10.7", - "ff 0.13.0", - "generic-array", - "group 0.13.0", - "pkcs8 0.10.2", - "rand_core 0.6.4", - "sec1 0.7.3", - "subtle", - "zeroize", -] - -[[package]] -name = "encoding_rs" -version = "0.8.34" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "enumset" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "226c0da7462c13fb57e5cc9e0dc8f0635e7d27f276a3a7fd30054647f669007d" -dependencies = [ - "enumset_derive", -] - -[[package]] -name = "enumset_derive" -version = "0.8.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e08b6c6ab82d70f08844964ba10c7babb716de2ecaeab9be5717918a5177d3af" -dependencies = [ - "darling", - "proc-macro2", - "quote", - "syn 2.0.64", -] - -[[package]] -name = "env_logger" -version = "0.9.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7" -dependencies = [ - "atty", - "humantime", - "log", - "regex", - "termcolor", -] - -[[package]] -name = "equivalent" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" - -[[package]] -name = "errno" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba" -dependencies = [ - "libc", - "windows-sys 0.52.0", -] - -[[package]] -name = "ethbloom" -version = "0.6.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3932e82d64d347a045208924002930dc105a138995ccdc1479d0f05f0359f17c" -dependencies = [ - "crunchy", - "fixed-hash 0.3.2", - "impl-rlp", - "impl-serde", - "tiny-keccak", -] - -[[package]] -name = "ethereum-types" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b054df51e53f253837ea422681215b42823c02824bde982699d0dceecf6165a1" -dependencies = [ - "crunchy", - "ethbloom", - "ethereum-types-serialize", - "fixed-hash 0.3.2", - "serde 1.0.202", - "uint 0.5.0", -] - -[[package]] -name = "ethereum-types-serialize" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1873d77b32bc1891a79dad925f2acbc318ee942b38b9110f9dbc5fbeffcea350" -dependencies = [ - "serde 1.0.202", -] - -[[package]] -name = "eyre" -version = "0.6.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7cd915d99f24784cdc19fd37ef22b97e3ff0ae756c7e492e9fbfe897d61e2aec" -dependencies = [ - "indenter", - "once_cell", -] - -[[package]] -name = "ff" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d013fc25338cc558c5c2cfbad646908fb23591e2404481826742b651c9af7160" -dependencies = [ - "rand_core 0.6.4", - "subtle", -] - -[[package]] -name = "ff" -version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449" -dependencies = [ - "rand_core 0.6.4", - "subtle", -] - -[[package]] -name = "fixed-hash" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d1a683d1234507e4f3bf2736eeddf0de1dc65996dc0164d57eba0a74bcf29489" -dependencies = [ - "byteorder", - "heapsize", - "rand 0.5.6", - "rustc-hex", - "static_assertions 0.2.5", -] - -[[package]] -name = "fixed-hash" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "835c052cb0c08c1acf6ffd71c022172e18723949c8282f2b9f27efbc51e64534" -dependencies = [ - "static_assertions 1.1.0", -] - -[[package]] -name = "flex-error" -version = "0.4.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c606d892c9de11507fa0dcffc116434f94e105d0bbdc4e405b61519464c49d7b" -dependencies = [ - "eyre", - "paste", -] - -[[package]] -name = "fnv" -version = "1.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" - -[[package]] -name = "form_urlencoded" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" -dependencies = [ - "percent-encoding", -] - -[[package]] -name = "forward_ref" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8cbd1169bd7b4a0a20d92b9af7a7e0422888bd38a6f5ec29c1fd8c1558a272e" - -[[package]] -name = "fuchsia-cprng" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba" - -[[package]] -name = "futures" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0" -dependencies = [ - "futures-channel", - "futures-core", - "futures-io", - "futures-sink", - "futures-task", - "futures-util", -] - -[[package]] -name = "futures-channel" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78" -dependencies = [ - "futures-core", - "futures-sink", -] - -[[package]] -name = "futures-core" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" - -[[package]] -name = "futures-io" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1" - -[[package]] -name = "futures-sink" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5" - -[[package]] -name = "futures-task" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" - -[[package]] -name = "futures-util" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" -dependencies = [ - "futures-core", - "futures-sink", - "futures-task", - "pin-project-lite", - "pin-utils", -] - -[[package]] -name = "gcc" -version = "0.3.55" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f5f3913fa0bfe7ee1fd8248b6b9f42a5af4b9d65ec2dd2c3c26132b950ecfc2" - -[[package]] -name = "generic-array" -version = "0.14.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" -dependencies = [ - "typenum", - "version_check", - "zeroize", -] - -[[package]] -name = "getrandom" -version = "0.2.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c" -dependencies = [ - "cfg-if", - "js-sys", - "libc", - "wasi", - "wasm-bindgen", -] - -[[package]] -name = "gimli" -version = "0.28.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253" - -[[package]] -name = "glob" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" - -[[package]] -name = "group" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5dfbfb3a6cfbd390d5c9564ab283a0349b9b9fcd46a706c1eb10e0db70bfbac7" -dependencies = [ - "ff 0.12.1", - "rand_core 0.6.4", - "subtle", -] - -[[package]] -name = "group" -version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" -dependencies = [ - "ff 0.13.0", - "rand_core 0.6.4", - "subtle", -] - -[[package]] -name = "h2" -version = "0.3.26" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8" -dependencies = [ - "bytes", - "fnv", - "futures-core", - "futures-sink", - "futures-util", - "http", - "indexmap 2.2.6", - "slab", - "tokio", - "tokio-util", - "tracing", -] - -[[package]] -name = "hashbrown" -version = "0.12.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" -dependencies = [ - "ahash", -] - -[[package]] -name = "hashbrown" -version = "0.14.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -<<<<<<< HEAD -checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604" -======= -checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 - -[[package]] -name = "heapsize" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1679e6ea370dee694f91f1dc469bf94cf8f52051d147aec3e1f9497c6fc22461" -dependencies = [ - "winapi", -] - -[[package]] -name = "hermit-abi" -version = "0.1.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" -dependencies = [ - "libc", -] - -[[package]] -name = "hermit-abi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024" - -[[package]] -name = "hex" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" -dependencies = [ - "serde 1.0.202", -] - -[[package]] -name = "hmac" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" -dependencies = [ - "digest 0.10.7", -] - -[[package]] -name = "home" -version = "0.5.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5" -dependencies = [ - "windows-sys 0.52.0", -] - -[[package]] -name = "http" -version = "0.2.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1" -dependencies = [ - "bytes", - "fnv", - "itoa", -] - -[[package]] -name = "http-body" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2" -dependencies = [ - "bytes", - "http", - "pin-project-lite", -] - -[[package]] -name = "httparse" -version = "1.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904" - -[[package]] -name = "httpdate" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" - -[[package]] -name = "humantime" -version = "2.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" - -[[package]] -name = "hyper" -version = "0.14.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80" -dependencies = [ - "bytes", - "futures-channel", - "futures-core", - "futures-util", - "h2", - "http", - "http-body", - "httparse", - "httpdate", - "itoa", - "pin-project-lite", - "socket2", - "tokio", - "tower-service", - "tracing", - "want", -] - -[[package]] -name = "hyper-rustls" -version = "0.24.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590" -dependencies = [ - "futures-util", - "http", - "hyper", - "rustls", - "tokio", - "tokio-rustls", -] - -[[package]] -name = "iana-time-zone" -version = "0.1.60" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141" -dependencies = [ - "android_system_properties", - "core-foundation-sys", - "iana-time-zone-haiku", - "js-sys", - "wasm-bindgen", - "windows-core", -] - -[[package]] -name = "iana-time-zone-haiku" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" -dependencies = [ - "cc", -] - -[[package]] -name = "ident_case" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" - -[[package]] -name = "idna" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6" -dependencies = [ - "unicode-bidi", - "unicode-normalization", -] - -[[package]] -name = "impl-rlp" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f7a72f11830b52333f36e3b09a288333888bf54380fd0ac0790a3c31ab0f3c5" -dependencies = [ - "rlp", -] - -[[package]] -name = "impl-serde" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "58e3cae7e99c7ff5a995da2cf78dd0a5383740eda71d98cf7b1910c301ac69b8" -dependencies = [ - "serde 1.0.202", -] - -[[package]] -name = "indenter" -version = "0.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce23b50ad8242c51a442f3ff322d56b02f08852c77e4c0b4d3fd684abc89c683" - -[[package]] -name = "indexmap" -version = "1.9.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99" -dependencies = [ - "autocfg", - "hashbrown 0.12.3", -] - -[[package]] -name = "indexmap" -version = "2.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26" -dependencies = [ - "equivalent", - "hashbrown 0.14.5", -] - -[[package]] -name = "injective-cosmwasm" -version = "0.2.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f85e8f06d04d0e20d59d673ae242c5cffb6a13f3b5189fd2e95ea153f3066f52" -dependencies = [ - "cosmwasm-std", - "cw-storage-plus 1.2.0", - "ethereum-types", - "hex", - "injective-math 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)", - "schemars", - "serde 1.0.202", - "serde_repr", - "subtle-encoding", - "tiny-keccak", -] - -[[package]] -name = "injective-cosmwasm" -version = "0.2.23-rc1" -dependencies = [ - "cosmwasm-schema", - "cosmwasm-std", - "cw-storage-plus 1.2.0", - "ethereum-types", - "hex", - "injective-math 0.2.4", - "schemars", - "serde 1.0.202", - "serde-json-wasm 1.0.1", - "serde_repr", - "serde_test", - "subtle-encoding", - "tiny-keccak", -] - -[[package]] -name = "injective-cosmwasm-mock" -version = "1.0.0" -dependencies = [ - "cosmos-sdk-proto", - "cosmwasm-schema", - "cosmwasm-std", - "cw-storage-plus 1.2.0", - "cw2 0.16.0", - "injective-cosmwasm 0.2.23-rc1", - "injective-math 0.2.4", - "injective-protobuf", -<<<<<<< HEAD - "injective-std", - "injective-test-tube", - "injective-testing 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", - "prost 0.12.3", -======= - "injective-std 0.1.7", - "injective-test-tube", - "injective-testing 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", - "prost 0.12.4", ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 - "protobuf 3.4.0", - "schemars", - "serde 1.0.202", - "thiserror", -] - -[[package]] -name = "injective-cosmwasm-stargate-example" -version = "0.0.1" -dependencies = [ - "base64 0.21.5", - "cosmos-sdk-proto", - "cosmwasm-schema", - "cosmwasm-std", - "cw-storage-plus 1.2.0", - "cw2 0.16.0", - "injective-cosmwasm 0.2.22", - "injective-math 0.2.4", - "injective-protobuf", - "injective-std", - "injective-test-tube", - "injective-testing 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", - "prost 0.12.3", - "protobuf 3.4.0", - "schemars", - "serde 1.0.197", - "serde_json 1.0.111", - "thiserror", -] - -[[package]] -name = "injective-math" -version = "0.2.4" -dependencies = [ - "cosmwasm-schema", - "cosmwasm-std", - "ethereum-types", - "primitive-types", - "schemars", - "serde 1.0.202", - "subtle-encoding", -] - -[[package]] -name = "injective-math" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db4e31ffb7dff274e0be1117bc8f1240f6572d6157be2c4daf13ff82eaaddd85" -dependencies = [ - "cosmwasm-std", - "ethereum-types", - "primitive-types", - "schemars", - "serde 1.0.202", - "subtle-encoding", -] - -[[package]] -name = "injective-protobuf" -version = "0.2.2" -dependencies = [ - "cosmwasm-schema", - "cosmwasm-std", - "ethereum-types", - "num 0.4.3", - "protobuf 2.28.0", - "protobuf-codegen-pure", - "schemars", - "serde 1.0.202", - "subtle-encoding", -] - -[[package]] -name = "injective-std" -<<<<<<< HEAD -version = "0.1.6" -======= -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1d7b7114796e44b034355983cb1ee2a1c9d1843df17c9552126e4404d463c06" -dependencies = [ - "chrono", - "cosmwasm-std", - "osmosis-std-derive", - "prost 0.12.4", - "prost-types 0.12.4", - "schemars", - "serde 1.0.202", - "serde-cw-value", -] - -[[package]] -name = "injective-std" -version = "1.12.10-testnet-rc2.1" ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 -dependencies = [ - "chrono", - "cosmwasm-std", - "osmosis-std-derive", -<<<<<<< HEAD - "prost 0.12.3", - "prost-types 0.12.3", -======= - "prost 0.12.4", - "prost-types 0.12.4", ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 - "schemars", - "serde 1.0.202", - "serde-cw-value", -] - -[[package]] -name = "injective-test-tube" -<<<<<<< HEAD -version = "1.1.8" -dependencies = [ - "base64 0.21.5", -======= -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2e7b985231e977f4202a8ef7112d34558473a1bdfb4bff8dcb8ab091909728f9" -dependencies = [ - "base64 0.21.7", ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 - "bindgen", - "cosmrs", - "cosmwasm-std", - "hex", -<<<<<<< HEAD - "injective-cosmwasm 0.2.18", - "injective-std", - "prost 0.12.3", - "serde 1.0.197", - "serde_json 1.0.111", -======= - "injective-cosmwasm 0.2.22", - "injective-std 0.1.7", - "prost 0.12.4", - "serde 1.0.202", - "serde_json 1.0.117", ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 - "test-tube-inj", - "thiserror", -] - -[[package]] -name = "injective-testing" -version = "0.1.6" -dependencies = [ - "anyhow", - "base64 0.13.1", - "cosmwasm-std", - "cw-multi-test", - "injective-cosmwasm 0.2.23-rc1", - "injective-math 0.2.4", - "rand 0.4.6", - "secp256k1", - "serde 1.0.202", - "tiny-keccak", -] - -[[package]] -name = "injective-testing" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49dc1d881d0b7726745ed776a87d1e6f93e877d2d5ebd0fe8be759f5424a091a" -dependencies = [ - "anyhow", - "base64 0.13.1", - "cosmwasm-std", - "cw-multi-test", - "injective-cosmwasm 0.2.22", - "injective-math 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)", - "rand 0.4.6", - "secp256k1", - "serde 1.0.202", - "tiny-keccak", -] - -[[package]] -name = "ipnet" -version = "2.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3" - -[[package]] -name = "itertools" -version = "0.10.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" -dependencies = [ - "either", -] - -[[package]] -name = "itertools" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569" -dependencies = [ - "either", -] - -[[package]] -name = "itoa" -version = "1.0.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" - -[[package]] -name = "js-sys" -version = "0.3.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d" -dependencies = [ - "wasm-bindgen", -] - -[[package]] -name = "k256" -version = "0.11.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72c1e0b51e7ec0a97369623508396067a486bd0cbed95a2659a4b863d28cfc8b" -dependencies = [ - "cfg-if", - "ecdsa 0.14.8", - "elliptic-curve 0.12.3", - "sha2 0.10.8", -] - -[[package]] -name = "k256" -version = "0.13.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cadb76004ed8e97623117f3df85b17aaa6626ab0b0831e6573f104df16cd1bcc" -dependencies = [ - "cfg-if", - "ecdsa 0.16.9", - "elliptic-curve 0.13.8", - "once_cell", - "sha2 0.10.8", - "signature 2.2.0", -] - -[[package]] -name = "lazy_static" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" - -[[package]] -name = "lazycell" -version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" - -[[package]] -name = "libc" -version = "0.2.153" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" - -[[package]] -name = "libloading" -version = "0.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19" -dependencies = [ - "cfg-if", - "windows-targets 0.52.5", -] - -[[package]] -name = "linux-raw-sys" -version = "0.4.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" - -[[package]] -name = "log" -version = "0.4.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c" - -[[package]] -name = "memchr" -version = "2.7.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d" - -[[package]] -name = "mime" -version = "0.3.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" - -[[package]] -name = "minimal-lexical" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" - -[[package]] -name = "miniz_oxide" -version = "0.7.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7" -dependencies = [ - "adler", -] - -[[package]] -name = "mio" -version = "0.8.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c" -dependencies = [ - "libc", - "wasi", - "windows-sys 0.48.0", -] - -[[package]] -name = "nodrop" -version = "0.1.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb" - -[[package]] -name = "nom" -version = "7.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" -dependencies = [ - "memchr", - "minimal-lexical", -] - -[[package]] -name = "num" -version = "0.1.42" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4703ad64153382334aa8db57c637364c322d3372e097840c72000dabdcf6156e" -dependencies = [ - "num-bigint 0.1.44", - "num-complex 0.1.43", - "num-integer", - "num-iter", - "num-rational 0.1.42", - "num-traits", -] - -[[package]] -name = "num" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23" -dependencies = [ - "num-bigint 0.4.5", - "num-complex 0.4.6", - "num-integer", - "num-iter", - "num-rational 0.4.2", - "num-traits", -] - -[[package]] -name = "num-bigint" -version = "0.1.44" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e63899ad0da84ce718c14936262a41cee2c79c981fc0a0e7c7beb47d5a07e8c1" -dependencies = [ - "num-integer", - "num-traits", - "rand 0.4.6", - "rustc-serialize", -] - -[[package]] -name = "num-bigint" -version = "0.4.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c165a9ab64cf766f73521c0dd2cfdff64f488b8f0b3e621face3462d3db536d7" -dependencies = [ - "num-integer", - "num-traits", -] - -[[package]] -name = "num-complex" -version = "0.1.43" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b288631d7878aaf59442cffd36910ea604ecd7745c36054328595114001c9656" -dependencies = [ - "num-traits", - "rustc-serialize", -] - -[[package]] -name = "num-complex" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" -dependencies = [ - "num-traits", -] - -[[package]] -name = "num-conv" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9" - -[[package]] -name = "num-derive" -version = "0.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "876a53fff98e03a936a674b29568b0e605f06b29372c2489ff4de23f1949743d" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "num-integer" -version = "0.1.46" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" -dependencies = [ - "num-traits", -] - -[[package]] -name = "num-iter" -version = "0.1.45" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf" -dependencies = [ - "autocfg", - "num-integer", - "num-traits", -] - -[[package]] -name = "num-rational" -version = "0.1.42" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee314c74bd753fc86b4780aa9475da469155f3848473a261d2d18e35245a784e" -dependencies = [ - "num-bigint 0.1.44", - "num-integer", - "num-traits", - "rustc-serialize", -] - -[[package]] -name = "num-rational" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824" -dependencies = [ - "num-bigint 0.4.5", - "num-integer", - "num-traits", -] - -[[package]] -name = "num-traits" -version = "0.2.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" -dependencies = [ - "autocfg", -] - -[[package]] -name = "num_cpus" -version = "1.16.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" -dependencies = [ - "hermit-abi 0.3.9", - "libc", -] - -[[package]] -name = "object" -version = "0.32.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441" -dependencies = [ - "memchr", -] - -[[package]] -name = "odds" -version = "0.2.26" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4eae0151b9dacf24fcc170d9995e511669a082856a91f958a2fe380bfab3fb22" - -[[package]] -name = "once_cell" -version = "1.19.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" - -[[package]] -name = "opaque-debug" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" - -[[package]] -name = "openssl-probe" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" - -[[package]] -name = "os_str_bytes" -version = "6.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2355d85b9a3786f481747ced0e0ff2ba35213a1f9bd406ed906554d7af805a1" - -[[package]] -name = "osmosis-std-derive" -version = "0.20.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c5ebdfd1bc8ed04db596e110c6baa9b174b04f6ed1ec22c666ddc5cb3fa91bd7" -dependencies = [ - "itertools 0.10.5", - "proc-macro2", - "prost-types 0.11.9", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "paste" -version = "1.0.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -<<<<<<< HEAD -checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c" -======= -checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 - -[[package]] -name = "peeking_take_while" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099" - -[[package]] -name = "peg" -<<<<<<< HEAD -version = "0.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "400bcab7d219c38abf8bd7cc2054eb9bbbd4312d66f6a5557d572a203f646f61" -======= -version = "0.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a625d12ad770914cbf7eff6f9314c3ef803bfe364a1b20bc36ddf56673e71e5" ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 -dependencies = [ - "peg-macros", - "peg-runtime", -] - -[[package]] -name = "peg-macros" -<<<<<<< HEAD -version = "0.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46e61cce859b76d19090f62da50a9fe92bab7c2a5f09e183763559a2ac392c90" -======= -version = "0.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f241d42067ed3ab6a4fece1db720838e1418f36d868585a27931f95d6bc03582" ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 -dependencies = [ - "peg-runtime", - "proc-macro2", - "quote", -] - -[[package]] -name = "peg-runtime" -<<<<<<< HEAD -version = "0.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36bae92c60fa2398ce4678b98b2c4b5a7c61099961ca1fa305aec04a9ad28922" -======= -version = "0.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3aeb8f54c078314c2065ee649a7241f46b9d8e418e1a9581ba0546657d7aa3a" ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 - -[[package]] -name = "percent-encoding" -version = "2.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" - -[[package]] -name = "pin-project" -version = "1.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3" -dependencies = [ - "pin-project-internal", -] - -[[package]] -name = "pin-project-internal" -version = "1.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.64", -] - -[[package]] -name = "pin-project-lite" -version = "0.2.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02" - -[[package]] -name = "pin-utils" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" - -[[package]] -name = "pkcs8" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9eca2c590a5f85da82668fa685c09ce2888b9430e83299debf1f34b65fd4a4ba" -dependencies = [ - "der 0.6.1", - "spki 0.6.0", -] - -[[package]] -name = "pkcs8" -version = "0.10.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7" -dependencies = [ - "der 0.7.9", - "spki 0.7.3", -] - -[[package]] -name = "powerfmt" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" - -[[package]] -name = "ppv-lite86" -version = "0.2.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" - -[[package]] -name = "primitive-types" -version = "0.12.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2" -dependencies = [ - "fixed-hash 0.8.0", - "uint 0.9.5", -] - -[[package]] -name = "proc-macro2" -version = "1.0.82" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ad3d49ab951a01fbaafe34f2ec74122942fe18a3f9814c3268f1bb72042131b" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "prost" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "444879275cb4fd84958b1a1d5420d15e6fcf7c235fe47f053c9c2a80aceb6001" -dependencies = [ - "bytes", - "prost-derive 0.9.0", -] - -[[package]] -name = "prost" -version = "0.11.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b82eaa1d779e9a4bc1c3217db8ffbeabaae1dca241bf70183242128d48681cd" -dependencies = [ - "bytes", - "prost-derive 0.11.9", -] - -[[package]] -name = "prost" -version = "0.12.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d0f5d036824e4761737860779c906171497f6d55681139d8312388f8fe398922" -dependencies = [ - "bytes", - "prost-derive 0.12.4", -] - -[[package]] -name = "prost-derive" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9cc1a3263e07e0bf68e96268f37665207b49560d98739662cdfaae215c720fe" -dependencies = [ - "anyhow", - "itertools 0.10.5", - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "prost-derive" -version = "0.11.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5d2d8d10f3c6ded6da8b05b5fb3b8a5082514344d56c9f871412d29b4e075b4" -dependencies = [ - "anyhow", - "itertools 0.10.5", - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "prost-derive" -version = "0.12.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19de2de2a00075bf566bee3bd4db014b11587e84184d3f7a791bc17f1a8e9e48" -dependencies = [ - "anyhow", - "itertools 0.12.1", - "proc-macro2", - "quote", - "syn 2.0.64", -] - -[[package]] -name = "prost-types" -version = "0.11.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "213622a1460818959ac1181aaeb2dc9c7f63df720db7d788b3e24eacd1983e13" -dependencies = [ - "prost 0.11.9", -] - -[[package]] -name = "prost-types" -version = "0.12.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3235c33eb02c1f1e212abdbe34c78b264b038fb58ca612664343271e36e55ffe" -dependencies = [ - "prost 0.12.4", -] - -[[package]] -name = "protobuf" -version = "2.28.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "106dd99e98437432fed6519dedecfade6a06a73bb7b2a1e019fdd2bee5778d94" -dependencies = [ - "bytes", -] - -[[package]] -name = "protobuf" -version = "3.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "58678a64de2fced2bdec6bca052a6716a0efe692d6e3f53d1bda6a1def64cfc0" -dependencies = [ - "once_cell", - "protobuf-support", - "thiserror", -] - -[[package]] -name = "protobuf-codegen" -version = "2.28.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "033460afb75cf755fcfc16dfaed20b86468082a2ea24e05ac35ab4a099a017d6" -dependencies = [ - "protobuf 2.28.0", -] - -[[package]] -name = "protobuf-codegen-pure" -version = "2.28.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95a29399fc94bcd3eeaa951c715f7bea69409b2445356b00519740bcd6ddd865" -dependencies = [ - "protobuf 2.28.0", - "protobuf-codegen", -] - -[[package]] -name = "protobuf-support" -version = "3.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1ed294a835b0f30810e13616b1cd34943c6d1e84a8f3b0dcfe466d256c3e7e7" -dependencies = [ - "thiserror", -] - -[[package]] -name = "quote" -version = "1.0.36" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "rand" -version = "0.3.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64ac302d8f83c0c1974bf758f6b041c6c8ada916fbb44a609158ca8b064cc76c" -dependencies = [ - "libc", - "rand 0.4.6", -] - -[[package]] -name = "rand" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293" -dependencies = [ - "fuchsia-cprng", - "libc", - "rand_core 0.3.1", - "rdrand", - "winapi", -] - -[[package]] -name = "rand" -version = "0.5.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c618c47cd3ebd209790115ab837de41425723956ad3ce2e6a7f09890947cacb9" -dependencies = [ - "cloudabi", - "fuchsia-cprng", - "libc", - "rand_core 0.3.1", - "winapi", -] - -[[package]] -name = "rand" -version = "0.8.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" -dependencies = [ - "libc", - "rand_chacha", - "rand_core 0.6.4", -] - -[[package]] -name = "rand_chacha" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" -dependencies = [ - "ppv-lite86", - "rand_core 0.6.4", -] - -[[package]] -name = "rand_core" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b" -dependencies = [ - "rand_core 0.4.2", -] - -[[package]] -name = "rand_core" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc" - -[[package]] -name = "rand_core" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" - -[[package]] -name = "rand_core" -version = "0.6.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" -dependencies = [ - "getrandom", -] - -[[package]] -name = "rdrand" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2" -dependencies = [ - "rand_core 0.3.1", -] - -[[package]] -name = "regex" -version = "1.10.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c" -dependencies = [ - "aho-corasick", - "memchr", - "regex-automata", - "regex-syntax", -] - -[[package]] -name = "regex-automata" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea" -dependencies = [ - "aho-corasick", - "memchr", - "regex-syntax", -] - -[[package]] -name = "regex-syntax" -version = "0.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56" - -[[package]] -name = "reqwest" -version = "0.11.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62" -dependencies = [ - "base64 0.21.7", - "bytes", - "encoding_rs", - "futures-core", - "futures-util", - "h2", - "http", - "http-body", - "hyper", - "hyper-rustls", - "ipnet", - "js-sys", - "log", - "mime", - "once_cell", - "percent-encoding", - "pin-project-lite", - "rustls", - "rustls-native-certs", - "rustls-pemfile", - "serde 1.0.202", - "serde_json 1.0.117", - "serde_urlencoded", - "sync_wrapper", - "system-configuration", - "tokio", - "tokio-rustls", - "tower-service", - "url", - "wasm-bindgen", - "wasm-bindgen-futures", - "web-sys", - "winreg", -] - -[[package]] -name = "reqwest" -version = "0.11.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62" -dependencies = [ - "base64 0.21.5", - "bytes", - "encoding_rs", - "futures-core", - "futures-util", - "h2", - "http", - "http-body", - "hyper", - "hyper-rustls", - "ipnet", - "js-sys", - "log", - "mime", - "once_cell", - "percent-encoding", - "pin-project-lite", - "rustls", - "rustls-native-certs", - "rustls-pemfile", - "serde 1.0.197", - "serde_json 1.0.111", - "serde_urlencoded", - "sync_wrapper", - "system-configuration", - "tokio", - "tokio-rustls", - "tower-service", - "url", - "wasm-bindgen", - "wasm-bindgen-futures", - "web-sys", - "winreg", -] - -[[package]] -name = "rfc6979" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7743f17af12fa0b03b803ba12cd6a8d9483a587e89c69445e3909655c0b9fabb" -dependencies = [ - "crypto-bigint 0.4.9", - "hmac", - "zeroize", -] - -[[package]] -name = "rfc6979" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2" -dependencies = [ - "hmac", - "subtle", -] - -[[package]] -name = "ring" -version = "0.17.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d" -dependencies = [ - "cc", - "cfg-if", - "getrandom", - "libc", - "spin", - "untrusted", - "windows-sys 0.52.0", -] - -[[package]] -name = "ripemd" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd124222d17ad93a644ed9d011a40f4fb64aa54275c08cc216524a9ea82fb09f" -dependencies = [ - "digest 0.10.7", -] - -[[package]] -name = "rlp" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1190dcc8c3a512f1eef5d09bb8c84c7f39e1054e174d1795482e18f5272f2e73" -dependencies = [ - "rustc-hex", -] - -[[package]] -name = "rustc-demangle" -version = "0.1.24" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f" - -[[package]] -name = "rustc-hash" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" - -[[package]] -name = "rustc-hex" -version = "2.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6" - -[[package]] -name = "rustc-serialize" -version = "0.3.25" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe834bc780604f4674073badbad26d7219cadfb4a2275802db12cbae17498401" - -[[package]] -name = "rustix" -version = "0.38.34" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f" -dependencies = [ - "bitflags 2.5.0", - "errno", - "libc", - "linux-raw-sys", - "windows-sys 0.52.0", -] - -[[package]] -name = "rustls" -<<<<<<< HEAD -version = "0.21.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fecbfb7b1444f477b345853b1fce097a2c6fb637b2bfb87e6bc5db0f043fae4" -======= -version = "0.21.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e" ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 -dependencies = [ - "log", - "ring", - "rustls-webpki", - "sct", -] - -[[package]] -name = "rustls-native-certs" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00" -dependencies = [ - "openssl-probe", - "rustls-pemfile", - "schannel", - "security-framework", -] - -[[package]] -name = "rustls-pemfile" -version = "1.0.4" -<<<<<<< HEAD -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" -dependencies = [ - "base64 0.21.5", -] - -[[package]] -name = "rustls-webpki" -version = "0.101.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" -dependencies = [ - "ring", - "untrusted", -] - -[[package]] -name = "ryu" -version = "1.0.16" -======= ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" -dependencies = [ - "base64 0.21.7", -] - -[[package]] -name = "rustls-webpki" -version = "0.101.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" -dependencies = [ - "ring", - "untrusted", -] - -[[package]] -name = "ryu" -version = "1.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" - -[[package]] -name = "same-file" -version = "1.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" -dependencies = [ - "winapi-util", -] - -[[package]] -name = "schannel" -version = "0.1.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534" -dependencies = [ - "windows-sys 0.52.0", -] - -[[package]] -name = "schemars" -version = "0.8.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc6e7ed6919cb46507fb01ff1654309219f62b4d603822501b0b80d42f6f21ef" -dependencies = [ - "dyn-clone", - "enumset", - "schemars_derive", - "serde 1.0.202", - "serde_json 1.0.117", -] - -[[package]] -name = "schemars_derive" -version = "0.8.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "185f2b7aa7e02d418e453790dde16890256bbd2bcd04b7dc5348811052b53f49" -dependencies = [ - "proc-macro2", - "quote", - "serde_derive_internals", - "syn 2.0.64", -] - -[[package]] -name = "sct" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414" -dependencies = [ - "ring", - "untrusted", -] - -[[package]] -name = "sec1" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3be24c1842290c45df0a7bf069e0c268a747ad05a192f2fd7dcfdbc1cba40928" -dependencies = [ - "base16ct 0.1.1", - "der 0.6.1", - "generic-array", - "pkcs8 0.9.0", - "subtle", - "zeroize", -] - -[[package]] -name = "sec1" -version = "0.7.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" -dependencies = [ - "base16ct 0.2.0", - "der 0.7.9", - "generic-array", - "pkcs8 0.10.2", - "subtle", - "zeroize", -] - -[[package]] -name = "secp256k1" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "10915a2fa4f8016ed747eb847f096b0d44b22c6b624a36d3cc76964f6af4821a" -dependencies = [ - "arrayvec", - "gcc", - "libc", - "rand 0.3.23", - "rustc-serialize", - "serde 0.6.15", - "serde_json 0.6.1", -] - -[[package]] -name = "security-framework" -version = "2.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c627723fd09706bacdb5cf41499e95098555af3c3c29d014dc3c458ef6be11c0" -dependencies = [ - "bitflags 2.5.0", - "core-foundation", - "core-foundation-sys", - "libc", - "security-framework-sys", -] - -[[package]] -name = "security-framework-sys" -version = "2.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "317936bbbd05227752583946b9e66d7ce3b489f84e11a94a510b4437fef407d7" -dependencies = [ - "core-foundation-sys", - "libc", -] - -[[package]] -name = "semver" -version = "1.0.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b" - -[[package]] -name = "serde" -version = "0.6.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c97b18e9e53de541f11e497357d6c5eaeb39f0cb9c8734e274abe4935f6991fa" -dependencies = [ - "num 0.1.42", -] - -[[package]] -name = "serde" -version = "1.0.202" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "226b61a0d411b2ba5ff6d7f73a476ac4f8bb900373459cd00fab8512828ba395" -dependencies = [ - "serde_derive", -] - -[[package]] -name = "serde-cw-value" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a75d32da6b8ed758b7d850b6c3c08f1d7df51a4df3cb201296e63e34a78e99d4" -dependencies = [ - "serde 1.0.202", -] - -[[package]] -name = "serde-json-wasm" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e9213a07d53faa0b8dd81e767a54a8188a242fdb9be99ab75ec576a774bfdd7" -dependencies = [ - "serde 1.0.202", -] - -[[package]] -name = "serde-json-wasm" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f05da0d153dd4595bdffd5099dc0e9ce425b205ee648eb93437ff7302af8c9a5" -dependencies = [ - "serde 1.0.202", -] - -[[package]] -name = "serde_bytes" -version = "0.11.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b8497c313fd43ab992087548117643f6fcd935cbf36f176ffda0aacf9591734" -dependencies = [ - "serde 1.0.202", -] - -[[package]] -name = "serde_derive" -version = "1.0.202" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6048858004bcff69094cd972ed40a32500f153bd3be9f716b2eed2e8217c4838" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.64", -] - -[[package]] -name = "serde_derive_internals" -version = "0.29.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.64", -] - -[[package]] -name = "serde_json" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5aaee47e038bf9552d30380d3973fff2593ee0a76d81ad4c581f267cdcadf36" -dependencies = [ - "num 0.1.42", - "serde 0.6.15", -] - -[[package]] -name = "serde_json" -version = "1.0.117" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3" -dependencies = [ - "itoa", - "ryu", - "serde 1.0.202", -] - -[[package]] -name = "serde_repr" -version = "0.1.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.64", -] - -[[package]] -name = "serde_test" -version = "1.0.176" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a2f49ace1498612d14f7e0b8245519584db8299541dfe31a06374a828d620ab" -dependencies = [ - "serde 1.0.202", -] - -[[package]] -name = "serde_urlencoded" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" -dependencies = [ - "form_urlencoded", - "itoa", - "ryu", -<<<<<<< HEAD - "serde 1.0.197", -======= - "serde 1.0.202", ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 -] - -[[package]] -name = "sha2" -version = "0.9.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800" -dependencies = [ - "block-buffer 0.9.0", - "cfg-if", - "cpufeatures", - "digest 0.9.0", - "opaque-debug", -] - -[[package]] -name = "sha2" -version = "0.10.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8" -dependencies = [ - "cfg-if", - "cpufeatures", - "digest 0.10.7", -] - -[[package]] -name = "shlex" -version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" - -[[package]] -name = "signature" -version = "1.6.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c" -dependencies = [ - "digest 0.10.7", - "rand_core 0.6.4", -] - -[[package]] -name = "signature" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" -dependencies = [ - "digest 0.10.7", - "rand_core 0.6.4", -] - -[[package]] -name = "slab" -version = "0.4.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" -dependencies = [ - "autocfg", -] - -[[package]] -name = "socket2" -version = "0.5.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c" -dependencies = [ - "libc", - "windows-sys 0.52.0", -] - -[[package]] -name = "spin" -version = "0.9.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" - -[[package]] -name = "spki" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67cf02bbac7a337dc36e4f5a693db6c21e7863f45070f7064577eb4367a3212b" -dependencies = [ - "base64ct", - "der 0.6.1", -] - -[[package]] -name = "spki" -version = "0.7.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d" -dependencies = [ - "base64ct", - "der 0.7.9", -] - -[[package]] -name = "static_assertions" -version = "0.2.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c19be23126415861cb3a23e501d34a708f7f9b2183c5252d690941c2e69199d5" - -[[package]] -name = "static_assertions" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" - -[[package]] -name = "strsim" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" - -[[package]] -name = "subtle" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc" - -[[package]] -name = "subtle-encoding" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7dcb1ed7b8330c5eed5441052651dd7a12c75e2ed88f2ec024ae1fa3a5e59945" -dependencies = [ - "zeroize", -] - -[[package]] -name = "subtle-ng" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "734676eb262c623cec13c3155096e08d1f8f29adce39ba17948b18dad1e54142" - -[[package]] -name = "syn" -version = "1.0.109" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "syn" -version = "2.0.64" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ad3dee41f36859875573074334c200d1add8e4a87bb37113ebd31d926b7b11f" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "sync_wrapper" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" - -[[package]] -name = "system-configuration" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7" -dependencies = [ - "bitflags 1.3.2", - "core-foundation", - "system-configuration-sys", -] - -[[package]] -name = "system-configuration-sys" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9" -dependencies = [ - "core-foundation-sys", - "libc", -] - -[[package]] -name = "tendermint" -version = "0.34.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15ab8f0a25d0d2ad49ac615da054d6a76aa6603ff95f7d18bafdd34450a1a04b" -dependencies = [ - "bytes", - "digest 0.10.7", - "ed25519", - "ed25519-consensus", - "flex-error", - "futures", - "k256 0.13.1", - "num-traits", - "once_cell", -<<<<<<< HEAD - "prost 0.12.3", - "prost-types 0.12.3", -======= - "prost 0.12.4", - "prost-types 0.12.4", ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 - "ripemd", - "serde 1.0.202", - "serde_bytes", - "serde_json 1.0.117", - "serde_repr", - "sha2 0.10.8", - "signature 2.2.0", - "subtle", - "subtle-encoding", - "tendermint-proto 0.34.1", - "time", - "zeroize", -] - -[[package]] -name = "tendermint-config" -version = "0.34.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1a02da769166e2052cd537b1a97c78017632c2d9e19266367b27e73910434fc" -dependencies = [ - "flex-error", - "serde 1.0.202", - "serde_json 1.0.117", - "tendermint", - "toml", - "url", -] - -[[package]] -name = "tendermint-proto" -version = "0.32.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0cec054567d16d85e8c3f6a3139963d1a66d9d3051ed545d31562550e9bcc3d" -dependencies = [ - "bytes", - "flex-error", - "num-derive", - "num-traits", - "prost 0.11.9", - "prost-types 0.11.9", - "serde 1.0.202", - "serde_bytes", - "subtle-encoding", - "time", -] - -[[package]] -name = "tendermint-proto" -version = "0.34.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b797dd3d2beaaee91d2f065e7bdf239dc8d80bba4a183a288bc1279dd5a69a1e" -dependencies = [ - "bytes", - "flex-error", - "num-derive", - "num-traits", - "prost 0.12.4", - "prost-types 0.12.4", - "serde 1.0.202", - "serde_bytes", - "subtle-encoding", - "time", -] - -[[package]] -name = "tendermint-rpc" -version = "0.34.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71afae8bb5f6b14ed48d4e1316a643b6c2c3cbad114f510be77b4ed20b7b3e42" -dependencies = [ - "async-trait", - "bytes", - "flex-error", - "futures", - "getrandom", - "peg", - "pin-project", - "rand 0.8.5", - "reqwest", - "semver", - "serde 1.0.202", - "serde_bytes", - "serde_json 1.0.117", - "subtle", - "subtle-encoding", - "tendermint", - "tendermint-config", - "tendermint-proto 0.34.1", - "thiserror", - "time", - "tokio", - "tracing", - "url", - "uuid", - "walkdir", -] - -[[package]] -name = "termcolor" -version = "1.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" -dependencies = [ - "winapi-util", -] - -[[package]] -name = "test-tube-inj" -<<<<<<< HEAD -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "751b40929081e03c825df424a5a81645f2cea444654d96f0aad962f7be4e541e" -dependencies = [ - "base64 0.21.5", - "cosmrs", - "cosmwasm-std", - "prost 0.12.3", - "serde 1.0.197", - "serde_json 1.0.111", -======= -version = "1.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd5deed958ebd3e60b9d55bb7773442993deac73e15f0354eb5bdab05df14fcb" -dependencies = [ - "base64 0.21.7", - "cosmrs", - "cosmwasm-std", - "prost 0.12.4", - "serde 1.0.202", - "serde_json 1.0.117", ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 - "tendermint-proto 0.32.2", - "thiserror", -] - -[[package]] -name = "textwrap" -version = "0.16.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23d434d3f8967a09480fb04132ebe0a3e088c173e6d0ee7897abbdf4eab0f8b9" - -[[package]] -name = "thiserror" -version = "1.0.60" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "579e9083ca58dd9dcf91a9923bb9054071b9ebbd800b342194c9feb0ee89fc18" -dependencies = [ - "thiserror-impl", -] - -[[package]] -name = "thiserror-impl" -version = "1.0.60" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2470041c06ec3ac1ab38d0356a6119054dedaea53e12fbefc0de730a1c08524" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.64", -] - -[[package]] -name = "time" -version = "0.3.36" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885" -dependencies = [ - "deranged", - "num-conv", - "powerfmt", - "serde 1.0.202", - "time-core", - "time-macros", -] - -[[package]] -name = "time-core" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3" - -[[package]] -name = "time-macros" -version = "0.2.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf" -dependencies = [ - "num-conv", - "time-core", -] - -[[package]] -name = "tiny-keccak" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d8a021c69bb74a44ccedb824a046447e2c84a01df9e5c20779750acb38e11b2" -dependencies = [ - "crunchy", -] - -[[package]] -name = "tinyvec" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50" -dependencies = [ - "tinyvec_macros", -] - -[[package]] -name = "tinyvec_macros" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" - -[[package]] -name = "tokio" -version = "1.37.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787" -dependencies = [ - "backtrace", - "bytes", - "libc", - "mio", - "num_cpus", - "pin-project-lite", - "socket2", - "tokio-macros", - "windows-sys 0.48.0", -] - -[[package]] -name = "tokio-macros" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.64", -] - -[[package]] -name = "tokio-rustls" -version = "0.24.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" -dependencies = [ - "rustls", - "tokio", -] - -[[package]] -name = "tokio-util" -version = "0.7.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1" -dependencies = [ - "bytes", - "futures-core", - "futures-sink", - "pin-project-lite", - "tokio", -] - -[[package]] -name = "toml" -version = "0.5.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234" -dependencies = [ - "serde 1.0.202", -] - -[[package]] -name = "tower-service" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52" - -[[package]] -name = "tracing" -version = "0.1.40" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef" -dependencies = [ - "pin-project-lite", - "tracing-core", -] - -[[package]] -name = "tracing-core" -version = "0.1.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54" -dependencies = [ - "once_cell", -] - -[[package]] -name = "try-lock" -version = "0.2.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" - -[[package]] -name = "typenum" -version = "1.17.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" - -[[package]] -name = "uint" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "082df6964410f6aa929a61ddfafc997e4f32c62c22490e439ac351cec827f436" -dependencies = [ - "byteorder", - "crunchy", - "heapsize", - "rustc-hex", -] - -[[package]] -name = "uint" -version = "0.9.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76f64bba2c53b04fcab63c01a7d7427eadc821e3bc48c34dc9ba29c501164b52" -dependencies = [ - "byteorder", - "crunchy", - "hex", - "static_assertions 1.1.0", -] - -[[package]] -name = "unicode-bidi" -version = "0.3.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75" - -[[package]] -name = "unicode-ident" -version = "1.0.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" - -[[package]] -name = "unicode-normalization" -version = "0.1.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5" -dependencies = [ - "tinyvec", -] - -[[package]] -name = "untrusted" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" - -[[package]] -name = "url" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633" -dependencies = [ - "form_urlencoded", - "idna", - "percent-encoding", -] - -[[package]] -name = "uuid" -version = "1.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0" - -[[package]] -name = "version_check" -version = "0.9.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" - -[[package]] -name = "walkdir" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" -dependencies = [ - "same-file", - "winapi-util", -] - -[[package]] -name = "want" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e" -dependencies = [ - "try-lock", -] - -[[package]] -name = "wasi" -version = "0.11.0+wasi-snapshot-preview1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" - -[[package]] -name = "wasm-bindgen" -version = "0.2.92" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8" -dependencies = [ - "cfg-if", - "wasm-bindgen-macro", -] - -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.92" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da" -dependencies = [ - "bumpalo", - "log", - "once_cell", - "proc-macro2", - "quote", - "syn 2.0.64", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-futures" -<<<<<<< HEAD -version = "0.4.39" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac36a15a220124ac510204aec1c3e5db8a22ab06fd6706d881dc6149f8ed9a12" -dependencies = [ - "cfg-if", - "js-sys", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.89" -======= -version = "0.4.42" ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0" -dependencies = [ - "cfg-if", - "js-sys", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.92" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726" -dependencies = [ - "quote", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.92" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.64", - "wasm-bindgen-backend", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.92" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96" - -[[package]] -name = "web-sys" -version = "0.3.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "which" -version = "4.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7" -dependencies = [ - "either", - "home", - "once_cell", - "rustix", -] - -[[package]] -name = "winapi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" -dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", -] - -[[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" - -[[package]] -name = "winapi-util" -version = "0.1.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b" -dependencies = [ - "windows-sys 0.52.0", -] - -[[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" - -[[package]] -name = "windows-core" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9" -dependencies = [ - "windows-targets 0.52.5", -] - -[[package]] -name = "windows-sys" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" -dependencies = [ - "windows-targets 0.48.5", -] - -[[package]] -name = "windows-sys" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" -dependencies = [ - "windows-targets 0.52.5", -] - -[[package]] -name = "windows-targets" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" -dependencies = [ - "windows_aarch64_gnullvm 0.48.5", - "windows_aarch64_msvc 0.48.5", - "windows_i686_gnu 0.48.5", - "windows_i686_msvc 0.48.5", - "windows_x86_64_gnu 0.48.5", - "windows_x86_64_gnullvm 0.48.5", - "windows_x86_64_msvc 0.48.5", -] - -[[package]] -name = "windows-targets" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb" -dependencies = [ - "windows_aarch64_gnullvm 0.52.5", - "windows_aarch64_msvc 0.52.5", - "windows_i686_gnu 0.52.5", - "windows_i686_gnullvm", - "windows_i686_msvc 0.52.5", - "windows_x86_64_gnu 0.52.5", - "windows_x86_64_gnullvm 0.52.5", - "windows_x86_64_msvc 0.52.5", -] - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6" - -[[package]] -name = "windows_i686_gnu" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" - -[[package]] -name = "windows_i686_gnu" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670" - -[[package]] -name = "windows_i686_gnullvm" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9" - -[[package]] -name = "windows_i686_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" - -[[package]] -name = "windows_i686_msvc" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0" - -[[package]] -name = "winreg" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" -dependencies = [ - "cfg-if", - "windows-sys 0.48.0", -] - -[[package]] -name = "winreg" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" -dependencies = [ - "cfg-if", - "windows-sys 0.48.0", -] - -[[package]] -name = "zeroize" -version = "1.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d" -dependencies = [ - "zeroize_derive", -] - -[[package]] -name = "zeroize_derive" -version = "1.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.64", -] diff --git a/contracts/injective-cosmwasm-mock/Cargo.toml b/contracts/injective-cosmwasm-mock/Cargo.toml index 82fc3b6e..e5017946 100644 --- a/contracts/injective-cosmwasm-mock/Cargo.toml +++ b/contracts/injective-cosmwasm-mock/Cargo.toml @@ -35,7 +35,7 @@ cosmwasm-schema = { version = "1.5.0" } cosmwasm-std = { version = "1.5.0", features = [ "abort", "cosmwasm_1_2", "cosmwasm_1_3", "cosmwasm_1_4", "iterator", "stargate" ] } cw-storage-plus = { version = "1.2.0" } cw2 = { version = "0.16.0" } -injective-cosmwasm = { path = "../../packages/injective-cosmwasm" } +injective-cosmwasm = { version = "0.2.23-rc1", path = "../../packages/injective-cosmwasm" } injective-math = { path = "../../packages/injective-math" } injective-protobuf = { path = "../../packages/injective-protobuf" } injective-std = { path = "../../packages/injective-std" } @@ -48,4 +48,4 @@ thiserror = { version = "1.0.56" } [dev-dependencies] injective-std = { path = "../../packages/injective-std" } injective-test-tube = { path = "/home/jose/RustroverProjects/test-tube/packages/injective-test-tube" } -injective-testing = { version = "0.1.6" } +injective-testing = { version = "0.1.6", path = "../../packages/injective-testing" } diff --git a/contracts/injective-cosmwasm-stargate-example/Cargo.toml b/contracts/injective-cosmwasm-stargate-example/Cargo.toml index ca7eaa6e..ec23f627 100644 --- a/contracts/injective-cosmwasm-stargate-example/Cargo.toml +++ b/contracts/injective-cosmwasm-stargate-example/Cargo.toml @@ -36,7 +36,7 @@ cosmwasm-schema = { version = "1.5.0" } cosmwasm-std = { version = "1.5.0", features = [ "abort", "cosmwasm_1_2", "cosmwasm_1_3", "cosmwasm_1_4", "iterator", "stargate" ] } cw-storage-plus = { version = "1.2.0" } cw2 = { version = "0.16.0" } -injective-cosmwasm = { path = "../../packages/injective-cosmwasm" } +injective-cosmwasm = { version = "0.2.23-rc1", path = "../../packages/injective-cosmwasm" } injective-math = { path = "../../packages/injective-math" } injective-protobuf = { path = "../../packages/injective-protobuf" } injective-std = { path = "../../packages/injective-std" } @@ -49,5 +49,5 @@ thiserror = { version = "1.0.56" } [dev-dependencies] injective-std = { path = "../../packages/injective-std" } -injective-test-tube = { path = "/Users/markuswaas/work/injective/test-tube/packages/injective-test-tube" } -injective-testing = { version = "0.1.6" } +injective-test-tube = { path = "/home/jose/RustroverProjects/test-tube/packages/injective-test-tube" } +injective-testing = { version = "0.1.6", path = "../../packages/injective-testing" } diff --git a/packages/injective-std/src/types/injective/exchange/v1beta1.rs b/packages/injective-std/src/types/injective/exchange/v1beta1.rs index da29be9e..99b737fa 100644 --- a/packages/injective-std/src/types/injective/exchange/v1beta1.rs +++ b/packages/injective-std/src/types/injective/exchange/v1beta1.rs @@ -1930,10 +1930,6 @@ pub struct MsgInstantPerpetualMarketLaunch { /// quantity #[prost(string, tag = "13")] pub min_quantity_tick_size: ::prost::alloc::string::String, -<<<<<<< HEAD -======= - ->>>>>>> 2d7e3f37cd11c43fd1ac4b3ae0908ad0d915e360 #[prost(string, tag = "14")] pub min_notional: ::prost::alloc::string::String, } From 01e5f5a5f2b4f806e997b23e3afeb4239d225de5 Mon Sep 17 00:00:00 2001 From: jbernal87 Date: Mon, 17 Jun 2024 14:30:12 +0200 Subject: [PATCH 08/19] chore: fix broken tests. --- .../src/testing/test_bank.rs | 2 ++ .../src/testing/test_oracle.rs | 2 -- contracts/injective-cosmwasm-stargate-example/src/utils.rs | 2 ++ 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs index 3e4280fe..e9cbdd00 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs @@ -35,6 +35,8 @@ fn test_query_denom_metadata() { let create_denom_msg = MsgCreateDenom { sender: env.users[0].account.address().to_string(), subdenom: "cw".to_string(), + name: "TEST_DENOM".to_string(), + symbol: "TDM".to_string(), }; let denom = token_factory.create_denom(create_denom_msg, &env.users[0].account).unwrap(); diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_oracle.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_oracle.rs index c6ebf71c..19a7fd08 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_oracle.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_oracle.rs @@ -59,13 +59,11 @@ fn test_query_oracle_volatility() { let base_info = Some(OracleInfo { symbol: env.denoms["base"].to_owned(), oracle_type: OracleType::PriceFeed as i32, - scale_factor: 6u32, }); let quote_info = Some(OracleInfo { symbol: env.denoms["quote"].to_owned(), oracle_type: OracleType::PriceFeed as i32, - scale_factor: 6u32, }); let oracle_history_options = Some(OracleHistoryOptions { diff --git a/contracts/injective-cosmwasm-stargate-example/src/utils.rs b/contracts/injective-cosmwasm-stargate-example/src/utils.rs index 2d65e8ae..57d4209e 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/utils.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/utils.rs @@ -416,6 +416,7 @@ pub fn add_spot_order_as(app: &InjectiveTestApp, market_id: String, trader: &Use fee_recipient: trader.account.address(), price, quantity, + cid: "".to_string(), }), order_type: order_type.into(), trigger_price: "".to_string(), @@ -541,6 +542,7 @@ pub fn add_derivative_order_as( fee_recipient: trader.address(), price, quantity, + cid: "".to_string(), }), margin, order_type: order_type.into(), From 8fc14a07d525fa7d53725a5fe0333208a27f0572 Mon Sep 17 00:00:00 2001 From: Markus Waas Date: Fri, 28 Jun 2024 11:59:23 +0200 Subject: [PATCH 09/19] chore: add to proto string helper to FPDecimal --- packages/injective-math/Cargo.toml | 2 +- packages/injective-math/src/fp_decimal/display.rs | 15 ++++++++++++++- packages/injective-math/src/fp_decimal/mod.rs | 2 +- packages/injective-math/src/fp_decimal/scale.rs | 4 +++- 4 files changed, 19 insertions(+), 4 deletions(-) diff --git a/packages/injective-math/Cargo.toml b/packages/injective-math/Cargo.toml index 15123d31..8f73488f 100644 --- a/packages/injective-math/Cargo.toml +++ b/packages/injective-math/Cargo.toml @@ -6,7 +6,7 @@ license = "Apache-2.0" name = "injective-math" readme = "README.md" repository = "https://github.com/InjectiveLabs/cw-injective/tree/dev/packages/injective-math" -version = "0.2.4" +version = "0.2.5" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/packages/injective-math/src/fp_decimal/display.rs b/packages/injective-math/src/fp_decimal/display.rs index 71d73ac4..16bbf5fd 100644 --- a/packages/injective-math/src/fp_decimal/display.rs +++ b/packages/injective-math/src/fp_decimal/display.rs @@ -1,4 +1,7 @@ -use crate::fp_decimal::FPDecimal; +use crate::{ + fp_decimal::FPDecimal, + scale::{Scaled, DEC_SCALE_FACTOR}, +}; use std::fmt; impl fmt::Display for FPDecimal { @@ -23,6 +26,16 @@ impl fmt::Display for FPDecimal { } } +pub trait ToProto { + fn to_proto_string(self) -> String; +} + +impl ToProto for FPDecimal { + fn to_proto_string(self) -> String { + self.scaled(DEC_SCALE_FACTOR).to_string() + } +} + #[cfg(test)] mod tests { use crate::FPDecimal; diff --git a/packages/injective-math/src/fp_decimal/mod.rs b/packages/injective-math/src/fp_decimal/mod.rs index 40c2bbcf..490d4648 100644 --- a/packages/injective-math/src/fp_decimal/mod.rs +++ b/packages/injective-math/src/fp_decimal/mod.rs @@ -383,7 +383,7 @@ impl FPDecimal { mod arithmetic; mod comparison; -mod display; +pub mod display; pub mod error; mod exp; mod factorial; diff --git a/packages/injective-math/src/fp_decimal/scale.rs b/packages/injective-math/src/fp_decimal/scale.rs index d2f0329f..094ee7dd 100644 --- a/packages/injective-math/src/fp_decimal/scale.rs +++ b/packages/injective-math/src/fp_decimal/scale.rs @@ -1,5 +1,7 @@ use crate::fp_decimal::FPDecimal; +pub const DEC_SCALE_FACTOR: i32 = 18; + pub trait Scaled { fn scaled(self, digits: i32) -> Self; } @@ -11,7 +13,7 @@ impl Scaled for FPDecimal { } pub fn dec_scale_factor() -> FPDecimal { - FPDecimal::ONE.scaled(18) + FPDecimal::ONE.scaled(DEC_SCALE_FACTOR) } #[cfg(test)] From a20cb205505bf83de4fc9f5c4009213eeb37eaf3 Mon Sep 17 00:00:00 2001 From: Markus Waas Date: Fri, 28 Jun 2024 12:01:10 +0200 Subject: [PATCH 10/19] chore: fix Cargo tomls --- Cargo.lock | 531 ++++++++---------- contracts/atomic-order-example/Cargo.toml | 6 +- contracts/dummy/Cargo.toml | 2 +- contracts/injective-cosmwasm-mock/Cargo.toml | 4 +- .../Cargo.toml | 4 +- packages/injective-testing/Cargo.toml | 2 +- 6 files changed, 233 insertions(+), 316 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3172cb4b..182c80c4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4,9 +4,9 @@ version = 3 [[package]] name = "addr2line" -version = "0.21.0" +version = "0.22.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb" +checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678" dependencies = [ "gimli", ] @@ -54,9 +54,9 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.83" +version = "1.0.86" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25bdb32cbbdce2b519a9cd7df3a678443100e265d5e25ca763b7572a5104f5f3" +checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da" [[package]] name = "arrayvec" @@ -76,7 +76,7 @@ checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca" dependencies = [ "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", ] [[package]] @@ -91,11 +91,11 @@ dependencies = [ "cw-utils 0.16.0", "cw2 0.16.0", "injective-cosmwasm 0.2.23-rc1", - "injective-math 0.2.4", + "injective-math 0.2.5", "injective-protobuf", "protobuf 2.28.0", "schemars", - "serde 1.0.202", + "serde 1.0.203", "thiserror", ] @@ -118,9 +118,9 @@ checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0" [[package]] name = "backtrace" -version = "0.3.71" +version = "0.3.73" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d" +checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a" dependencies = [ "addr2line", "cc", @@ -198,7 +198,7 @@ checksum = "7e141fb0f8be1c7b45887af94c88b182472b57c96b56773250ae00cd6a14a164" dependencies = [ "bs58", "hmac", - "k256 0.13.2", + "k256 0.13.1", "rand_core 0.6.4", "ripemd", "sha2 0.10.8", @@ -214,9 +214,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.5.0" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" +checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" [[package]] name = "block-buffer" @@ -269,14 +269,14 @@ version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9" dependencies = [ - "serde 1.0.202", + "serde 1.0.203", ] [[package]] name = "cc" -version = "1.0.97" +version = "1.0.100" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "099a5357d84c4c61eb35fc8eafa9a79a902c2f76911e5747ced4e032edd8d9b4" +checksum = "c891175c3fb232128f48de6590095e59198bbeb8620c310be349bfc3afd12c7b" [[package]] name = "cexpr" @@ -309,9 +309,9 @@ dependencies = [ [[package]] name = "clang-sys" -version = "1.7.0" +version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67523a3b4be3ce1989d607a828d036249522dd9c1c8de7f4dd2dae43a37369d1" +checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4" dependencies = [ "glob", "libc", @@ -379,8 +379,8 @@ version = "0.20.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32560304ab4c365791fd307282f76637213d8083c1a98490c35159cd67852237" dependencies = [ - "prost 0.12.4", - "prost-types 0.12.4", + "prost 0.12.6", + "prost-types 0.12.6", "tendermint-proto 0.34.1", ] @@ -394,10 +394,10 @@ dependencies = [ "cosmos-sdk-proto", "ecdsa 0.16.9", "eyre", - "k256 0.13.2", + "k256 0.13.1", "rand_core 0.6.4", - "serde 1.0.197", - "serde_json 1.0.111", + "serde 1.0.203", + "serde_json 1.0.118", "signature 2.2.0", "subtle-encoding", "tendermint", @@ -436,8 +436,8 @@ checksum = "7879036156092ad1c22fe0d7316efc5a5eceec2bc3906462a2560215f2a2f929" dependencies = [ "cosmwasm-schema-derive", "schemars", - "serde 1.0.202", - "serde_json 1.0.117", + "serde 1.0.203", + "serde_json 1.0.118", "thiserror", ] @@ -467,7 +467,7 @@ dependencies = [ "forward_ref", "hex", "schemars", - "serde 1.0.202", + "serde 1.0.203", "serde-json-wasm 0.5.2", "sha2 0.10.8", "static_assertions 1.1.0", @@ -481,7 +481,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "66de2ab9db04757bcedef2b5984fbe536903ada4a8a9766717a4a71197ef34f6" dependencies = [ "cosmwasm-std", - "serde 1.0.202", + "serde 1.0.203", ] [[package]] @@ -574,7 +574,7 @@ dependencies = [ "k256 0.11.6", "prost 0.9.0", "schemars", - "serde 1.0.202", + "serde 1.0.203", "thiserror", ] @@ -586,7 +586,7 @@ checksum = "d9b6f91c0b94481a3e9ef1ceb183c37d00764f8751e39b45fc09f4d9b970d469" dependencies = [ "cosmwasm-std", "schemars", - "serde 1.0.202", + "serde 1.0.203", ] [[package]] @@ -597,7 +597,7 @@ checksum = "d5ff29294ee99373e2cd5fd21786a3c0ced99a52fec2ca347d565489c61b723c" dependencies = [ "cosmwasm-std", "schemars", - "serde 1.0.202", + "serde 1.0.203", ] [[package]] @@ -611,7 +611,7 @@ dependencies = [ "cw2 0.16.0", "schemars", "semver", - "serde 1.0.202", + "serde 1.0.203", "thiserror", ] @@ -626,7 +626,7 @@ dependencies = [ "cw2 1.1.2", "schemars", "semver", - "serde 1.0.202", + "serde 1.0.203", "thiserror", ] @@ -640,7 +640,7 @@ dependencies = [ "cosmwasm-std", "cw-storage-plus 0.16.0", "schemars", - "serde 1.0.202", + "serde 1.0.203", ] [[package]] @@ -654,7 +654,7 @@ dependencies = [ "cw-storage-plus 1.2.0", "schemars", "semver", - "serde 1.0.202", + "serde 1.0.203", "thiserror", ] @@ -678,7 +678,7 @@ dependencies = [ "ident_case", "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", ] [[package]] @@ -689,7 +689,7 @@ checksum = "733cabb43482b1a1b53eee8583c2b9e8684d592215ea83efd305dd31bc2f0178" dependencies = [ "darling_core", "quote", - "syn 2.0.64", + "syn 2.0.68", ] [[package]] @@ -762,7 +762,7 @@ dependencies = [ "cw2 0.16.0", "injective-cosmwasm 0.2.23-rc1", "schemars", - "serde 1.0.202", + "serde 1.0.203", "thiserror", ] @@ -831,7 +831,7 @@ dependencies = [ "hashbrown 0.12.3", "hex", "rand_core 0.6.4", - "serde 1.0.202", + "serde 1.0.203", "sha2 0.9.9", "zeroize", ] @@ -908,7 +908,7 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", ] [[package]] @@ -963,7 +963,7 @@ dependencies = [ "ethbloom", "ethereum-types-serialize", "fixed-hash 0.3.2", - "serde 1.0.202", + "serde 1.0.203", "uint 0.5.0", ] @@ -973,7 +973,7 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1873d77b32bc1891a79dad925f2acbc318ee942b38b9110f9dbc5fbeffcea350" dependencies = [ - "serde 1.0.202", + "serde 1.0.203", ] [[package]] @@ -1145,9 +1145,9 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.2.14" +version = "0.2.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c" +checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7" dependencies = [ "cfg-if", "js-sys", @@ -1158,9 +1158,9 @@ dependencies = [ [[package]] name = "gimli" -version = "0.28.1" +version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253" +checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd" [[package]] name = "glob" @@ -1222,7 +1222,7 @@ dependencies = [ name = "hashbrown" version = "0.14.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604" +checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" [[package]] name = "heapsize" @@ -1254,7 +1254,7 @@ version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" dependencies = [ - "serde 1.0.202", + "serde 1.0.203", ] [[package]] @@ -1299,9 +1299,9 @@ dependencies = [ [[package]] name = "httparse" -version = "1.8.0" +version = "1.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904" +checksum = "0fcc0b4a115bf80b728eb8ea024ad5bd707b615bfed49e0665b6e0f86fd082d9" [[package]] name = "httpdate" @@ -1317,9 +1317,9 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" [[package]] name = "hyper" -version = "0.14.28" +version = "0.14.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80" +checksum = "f361cde2f109281a220d4307746cdfd5ee3f410da58a70377762396775634b33" dependencies = [ "bytes", "futures-channel", @@ -1407,7 +1407,7 @@ version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "58e3cae7e99c7ff5a995da2cf78dd0a5383740eda71d98cf7b1910c301ac69b8" dependencies = [ - "serde 1.0.202", + "serde 1.0.203", ] [[package]] @@ -1438,18 +1438,19 @@ dependencies = [ [[package]] name = "injective-cosmwasm" -version = "0.2.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f85e8f06d04d0e20d59d673ae242c5cffb6a13f3b5189fd2e95ea153f3066f52" +version = "0.2.23-rc1" dependencies = [ + "cosmwasm-schema", "cosmwasm-std", "cw-storage-plus 1.2.0", "ethereum-types", "hex", - "injective-math 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)", + "injective-math 0.2.5", "schemars", - "serde 1.0.202", + "serde 1.0.203", + "serde-json-wasm 1.0.1", "serde_repr", + "serde_test", "subtle-encoding", "tiny-keccak", ] @@ -1457,18 +1458,17 @@ dependencies = [ [[package]] name = "injective-cosmwasm" version = "0.2.23-rc1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1de3ef4767134652a523ca4ed9fb4d512856af2cfa85161cc36334321024ab23" dependencies = [ - "cosmwasm-schema", "cosmwasm-std", "cw-storage-plus 1.2.0", "ethereum-types", "hex", "injective-math 0.2.4", "schemars", - "serde 1.0.202", - "serde-json-wasm 1.0.1", + "serde 1.0.203", "serde_repr", - "serde_test", "subtle-encoding", "tiny-keccak", ] @@ -1483,15 +1483,15 @@ dependencies = [ "cw-storage-plus 1.2.0", "cw2 0.16.0", "injective-cosmwasm 0.2.23-rc1", - "injective-math 0.2.4", + "injective-math 0.2.5", "injective-protobuf", - "injective-std", + "injective-std 1.12.10-testnet-rc2.1", "injective-test-tube", - "injective-testing 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", - "prost 0.12.3", + "injective-testing", + "prost 0.12.6", "protobuf 3.4.0", "schemars", - "serde 1.0.202", + "serde 1.0.203", "thiserror", ] @@ -1499,50 +1499,50 @@ dependencies = [ name = "injective-cosmwasm-stargate-example" version = "0.0.1" dependencies = [ - "base64 0.21.5", + "base64 0.21.7", "cosmos-sdk-proto", "cosmwasm-schema", "cosmwasm-std", "cw-storage-plus 1.2.0", "cw2 0.16.0", - "injective-cosmwasm 0.2.22", - "injective-math 0.2.4", + "injective-cosmwasm 0.2.23-rc1", + "injective-math 0.2.5", "injective-protobuf", - "injective-std", + "injective-std 1.12.10-testnet-rc2.1", "injective-test-tube", - "injective-testing 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", - "prost 0.12.3", + "injective-testing", + "prost 0.12.6", "protobuf 3.4.0", "schemars", - "serde 1.0.197", - "serde_json 1.0.111", + "serde 1.0.203", + "serde_json 1.0.118", "thiserror", ] [[package]] name = "injective-math" version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db4e31ffb7dff274e0be1117bc8f1240f6572d6157be2c4daf13ff82eaaddd85" dependencies = [ - "cosmwasm-schema", "cosmwasm-std", "ethereum-types", "primitive-types", "schemars", - "serde 1.0.202", + "serde 1.0.203", "subtle-encoding", ] [[package]] name = "injective-math" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db4e31ffb7dff274e0be1117bc8f1240f6572d6157be2c4daf13ff82eaaddd85" +version = "0.2.5" dependencies = [ + "cosmwasm-schema", "cosmwasm-std", "ethereum-types", "primitive-types", "schemars", - "serde 1.0.202", + "serde 1.0.203", "subtle-encoding", ] @@ -1557,38 +1557,55 @@ dependencies = [ "protobuf 2.28.0", "protobuf-codegen-pure", "schemars", - "serde 1.0.202", + "serde 1.0.203", "subtle-encoding", ] [[package]] name = "injective-std" -version = "0.1.6" +version = "1.12.10-testnet-rc2.1" +dependencies = [ + "chrono", + "cosmwasm-std", + "osmosis-std-derive", + "prost 0.12.6", + "prost-types 0.12.6", + "schemars", + "serde 1.0.203", + "serde-cw-value", +] + +[[package]] +name = "injective-std" +version = "1.12.11-testnet-rc1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cf1dda243d7525e0d7cbab7cc481aa63674b4be83faf094a395061a21e9905a" dependencies = [ "chrono", "cosmwasm-std", "osmosis-std-derive", - "prost 0.12.3", - "prost-types 0.12.3", + "prost 0.12.6", + "prost-types 0.12.6", "schemars", - "serde 1.0.202", + "serde 1.0.203", "serde-cw-value", ] [[package]] name = "injective-test-tube" -version = "1.1.8" +version = "1.2.0-d0e5f735acc244f35a4f3b856f293277c8ee227e" +source = "git+https://github.com/InjectiveLabs/test-tube?branch=latest#8c723e31e51008ccb733f55c26da5432a9ccd55d" dependencies = [ - "base64 0.21.5", + "base64 0.21.7", "bindgen", "cosmrs", "cosmwasm-std", "hex", - "injective-cosmwasm 0.2.18", - "injective-std", - "prost 0.12.3", - "serde 1.0.197", - "serde_json 1.0.111", + "injective-cosmwasm 0.2.23-rc1 (registry+https://github.com/rust-lang/crates.io-index)", + "injective-std 1.12.11-testnet-rc1", + "prost 0.12.6", + "serde 1.0.203", + "serde_json 1.0.118", "test-tube-inj", "thiserror", ] @@ -1602,28 +1619,10 @@ dependencies = [ "cosmwasm-std", "cw-multi-test", "injective-cosmwasm 0.2.23-rc1", - "injective-math 0.2.4", - "rand 0.4.6", - "secp256k1", - "serde 1.0.202", - "tiny-keccak", -] - -[[package]] -name = "injective-testing" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49dc1d881d0b7726745ed776a87d1e6f93e877d2d5ebd0fe8be759f5424a091a" -dependencies = [ - "anyhow", - "base64 0.13.1", - "cosmwasm-std", - "cw-multi-test", - "injective-cosmwasm 0.2.22", - "injective-math 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)", + "injective-math 0.2.5", "rand 0.4.6", "secp256k1", - "serde 1.0.202", + "serde 1.0.203", "tiny-keccak", ] @@ -1694,9 +1693,9 @@ dependencies = [ [[package]] name = "lazy_static" -version = "1.4.0" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" [[package]] name = "lazycell" @@ -1706,15 +1705,15 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" [[package]] name = "libc" -version = "0.2.153" +version = "0.2.155" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" +checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" [[package]] name = "libloading" -version = "0.8.3" +version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19" +checksum = "e310b3a6b5907f99202fcdb4960ff45b93735d7c7d96b760fcff8db2dc0e103d" dependencies = [ "cfg-if", "windows-targets 0.52.5", @@ -1734,9 +1733,9 @@ checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c" [[package]] name = "memchr" -version = "2.7.2" +version = "2.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "mime" @@ -1752,9 +1751,9 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" [[package]] name = "miniz_oxide" -version = "0.7.2" +version = "0.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7" +checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08" dependencies = [ "adler", ] @@ -1936,9 +1935,9 @@ dependencies = [ [[package]] name = "object" -version = "0.32.2" +version = "0.36.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441" +checksum = "576dfe1fc8f9df304abb159d767a29d0476f7750fbf8aa7ad07816004a207434" dependencies = [ "memchr", ] @@ -1990,7 +1989,7 @@ dependencies = [ name = "paste" version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" [[package]] name = "peeking_take_while" @@ -2000,9 +1999,9 @@ checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099" [[package]] name = "peg" -version = "0.8.2" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "400bcab7d219c38abf8bd7cc2054eb9bbbd4312d66f6a5557d572a203f646f61" +checksum = "8a625d12ad770914cbf7eff6f9314c3ef803bfe364a1b20bc36ddf56673e71e5" dependencies = [ "peg-macros", "peg-runtime", @@ -2010,9 +2009,9 @@ dependencies = [ [[package]] name = "peg-macros" -version = "0.8.2" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46e61cce859b76d19090f62da50a9fe92bab7c2a5f09e183763559a2ac392c90" +checksum = "f241d42067ed3ab6a4fece1db720838e1418f36d868585a27931f95d6bc03582" dependencies = [ "peg-runtime", "proc-macro2", @@ -2021,9 +2020,9 @@ dependencies = [ [[package]] name = "peg-runtime" -version = "0.8.2" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36bae92c60fa2398ce4678b98b2c4b5a7c61099961ca1fa305aec04a9ad28922" +checksum = "e3aeb8f54c078314c2065ee649a7241f46b9d8e418e1a9581ba0546657d7aa3a" [[package]] name = "percent-encoding" @@ -2048,7 +2047,7 @@ checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965" dependencies = [ "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", ] [[package]] @@ -2107,9 +2106,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.82" +version = "1.0.86" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ad3d49ab951a01fbaafe34f2ec74122942fe18a3f9814c3268f1bb72042131b" +checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77" dependencies = [ "unicode-ident", ] @@ -2136,12 +2135,12 @@ dependencies = [ [[package]] name = "prost" -version = "0.12.4" +version = "0.12.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d0f5d036824e4761737860779c906171497f6d55681139d8312388f8fe398922" +checksum = "deb1435c188b76130da55f17a466d252ff7b1418b2ad3e037d127b94e3411f29" dependencies = [ "bytes", - "prost-derive 0.12.4", + "prost-derive 0.12.6", ] [[package]] @@ -2172,15 +2171,15 @@ dependencies = [ [[package]] name = "prost-derive" -version = "0.12.4" +version = "0.12.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19de2de2a00075bf566bee3bd4db014b11587e84184d3f7a791bc17f1a8e9e48" +checksum = "81bddcdb20abf9501610992b6759a4c888aef7d1a7247ef75e2404275ac24af1" dependencies = [ "anyhow", "itertools 0.12.1", "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", ] [[package]] @@ -2194,11 +2193,11 @@ dependencies = [ [[package]] name = "prost-types" -version = "0.12.4" +version = "0.12.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3235c33eb02c1f1e212abdbe34c78b264b038fb58ca612664343271e36e55ffe" +checksum = "9091c90b0a32608e984ff2fa4091273cbdd755d54935c51d520887f4a1dbd5b0" dependencies = [ - "prost 0.12.4", + "prost 0.12.6", ] [[package]] @@ -2356,9 +2355,9 @@ dependencies = [ [[package]] name = "regex" -version = "1.10.4" +version = "1.10.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c" +checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f" dependencies = [ "aho-corasick", "memchr", @@ -2368,9 +2367,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.6" +version = "0.4.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea" +checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df" dependencies = [ "aho-corasick", "memchr", @@ -2379,9 +2378,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.3" +version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56" +checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b" [[package]] name = "reqwest" @@ -2409,49 +2408,8 @@ dependencies = [ "rustls", "rustls-native-certs", "rustls-pemfile", - "serde 1.0.202", - "serde_json 1.0.117", - "serde_urlencoded", - "sync_wrapper", - "system-configuration", - "tokio", - "tokio-rustls", - "tower-service", - "url", - "wasm-bindgen", - "wasm-bindgen-futures", - "web-sys", - "winreg", -] - -[[package]] -name = "reqwest" -version = "0.11.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62" -dependencies = [ - "base64 0.21.5", - "bytes", - "encoding_rs", - "futures-core", - "futures-util", - "h2", - "http", - "http-body", - "hyper", - "hyper-rustls", - "ipnet", - "js-sys", - "log", - "mime", - "once_cell", - "percent-encoding", - "pin-project-lite", - "rustls", - "rustls-native-certs", - "rustls-pemfile", - "serde 1.0.197", - "serde_json 1.0.111", + "serde 1.0.203", + "serde_json 1.0.118", "serde_urlencoded", "sync_wrapper", "system-configuration", @@ -2549,7 +2507,7 @@ version = "0.38.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "errno", "libc", "linux-raw-sys", @@ -2558,9 +2516,9 @@ dependencies = [ [[package]] name = "rustls" -version = "0.21.11" +version = "0.21.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fecbfb7b1444f477b345853b1fce097a2c6fb637b2bfb87e6bc5db0f043fae4" +checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e" dependencies = [ "log", "ring", @@ -2585,25 +2543,6 @@ name = "rustls-pemfile" version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" -dependencies = [ - "base64 0.21.5", -] - -[[package]] -name = "rustls-webpki" -version = "0.101.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" -dependencies = [ - "ring", - "untrusted", -] - -[[package]] -name = "ryu" -version = "1.0.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" dependencies = [ "base64 0.21.7", ] @@ -2644,27 +2583,27 @@ dependencies = [ [[package]] name = "schemars" -version = "0.8.19" +version = "0.8.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc6e7ed6919cb46507fb01ff1654309219f62b4d603822501b0b80d42f6f21ef" +checksum = "09c024468a378b7e36765cd36702b7a90cc3cba11654f6685c8f233408e89e92" dependencies = [ "dyn-clone", "enumset", "schemars_derive", - "serde 1.0.202", - "serde_json 1.0.117", + "serde 1.0.203", + "serde_json 1.0.118", ] [[package]] name = "schemars_derive" -version = "0.8.19" +version = "0.8.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "185f2b7aa7e02d418e453790dde16890256bbd2bcd04b7dc5348811052b53f49" +checksum = "b1eee588578aff73f856ab961cd2f79e36bc45d7ded33a7562adba4667aecc0e" dependencies = [ "proc-macro2", "quote", "serde_derive_internals", - "syn 2.0.64", + "syn 2.0.68", ] [[package]] @@ -2726,7 +2665,7 @@ version = "2.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c627723fd09706bacdb5cf41499e95098555af3c3c29d014dc3c458ef6be11c0" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "core-foundation", "core-foundation-sys", "libc", @@ -2760,9 +2699,9 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.202" +version = "1.0.203" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "226b61a0d411b2ba5ff6d7f73a476ac4f8bb900373459cd00fab8512828ba395" +checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094" dependencies = [ "serde_derive", ] @@ -2773,7 +2712,7 @@ version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a75d32da6b8ed758b7d850b6c3c08f1d7df51a4df3cb201296e63e34a78e99d4" dependencies = [ - "serde 1.0.202", + "serde 1.0.203", ] [[package]] @@ -2782,7 +2721,7 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9e9213a07d53faa0b8dd81e767a54a8188a242fdb9be99ab75ec576a774bfdd7" dependencies = [ - "serde 1.0.202", + "serde 1.0.203", ] [[package]] @@ -2791,27 +2730,27 @@ version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f05da0d153dd4595bdffd5099dc0e9ce425b205ee648eb93437ff7302af8c9a5" dependencies = [ - "serde 1.0.202", + "serde 1.0.203", ] [[package]] name = "serde_bytes" -version = "0.11.14" +version = "0.11.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b8497c313fd43ab992087548117643f6fcd935cbf36f176ffda0aacf9591734" +checksum = "387cc504cb06bb40a96c8e04e951fe01854cf6bc921053c954e4a606d9675c6a" dependencies = [ - "serde 1.0.202", + "serde 1.0.203", ] [[package]] name = "serde_derive" -version = "1.0.202" +version = "1.0.203" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6048858004bcff69094cd972ed40a32500f153bd3be9f716b2eed2e8217c4838" +checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba" dependencies = [ "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", ] [[package]] @@ -2822,7 +2761,7 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711" dependencies = [ "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", ] [[package]] @@ -2837,13 +2776,13 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.117" +version = "1.0.118" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3" +checksum = "d947f6b3163d8857ea16c4fa0dd4840d52f3041039a85decd46867eb1abef2e4" dependencies = [ "itoa", "ryu", - "serde 1.0.202", + "serde 1.0.203", ] [[package]] @@ -2854,7 +2793,7 @@ checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9" dependencies = [ "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", ] [[package]] @@ -2863,7 +2802,7 @@ version = "1.0.176" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5a2f49ace1498612d14f7e0b8245519584db8299541dfe31a06374a828d620ab" dependencies = [ - "serde 1.0.202", + "serde 1.0.203", ] [[package]] @@ -2875,7 +2814,7 @@ dependencies = [ "form_urlencoded", "itoa", "ryu", - "serde 1.0.197", + "serde 1.0.203", ] [[package]] @@ -2993,9 +2932,9 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" [[package]] name = "subtle" -version = "2.5.0" +version = "2.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" [[package]] name = "subtle-encoding" @@ -3025,9 +2964,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.64" +version = "2.0.68" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ad3dee41f36859875573074334c200d1add8e4a87bb37113ebd31d926b7b11f" +checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9" dependencies = [ "proc-macro2", "quote", @@ -3076,12 +3015,12 @@ dependencies = [ "k256 0.13.1", "num-traits", "once_cell", - "prost 0.12.3", - "prost-types 0.12.3", + "prost 0.12.6", + "prost-types 0.12.6", "ripemd", - "serde 1.0.202", + "serde 1.0.203", "serde_bytes", - "serde_json 1.0.117", + "serde_json 1.0.118", "serde_repr", "sha2 0.10.8", "signature 2.2.0", @@ -3099,8 +3038,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e1a02da769166e2052cd537b1a97c78017632c2d9e19266367b27e73910434fc" dependencies = [ "flex-error", - "serde 1.0.202", - "serde_json 1.0.117", + "serde 1.0.203", + "serde_json 1.0.118", "tendermint", "toml", "url", @@ -3118,7 +3057,7 @@ dependencies = [ "num-traits", "prost 0.11.9", "prost-types 0.11.9", - "serde 1.0.202", + "serde 1.0.203", "serde_bytes", "subtle-encoding", "time", @@ -3134,9 +3073,9 @@ dependencies = [ "flex-error", "num-derive", "num-traits", - "prost 0.12.4", - "prost-types 0.12.4", - "serde 1.0.202", + "prost 0.12.6", + "prost-types 0.12.6", + "serde 1.0.203", "serde_bytes", "subtle-encoding", "time", @@ -3158,9 +3097,9 @@ dependencies = [ "rand 0.8.5", "reqwest", "semver", - "serde 1.0.202", + "serde 1.0.203", "serde_bytes", - "serde_json 1.0.117", + "serde_json 1.0.118", "subtle", "subtle-encoding", "tendermint", @@ -3186,16 +3125,16 @@ dependencies = [ [[package]] name = "test-tube-inj" -version = "1.1.3" +version = "1.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "751b40929081e03c825df424a5a81645f2cea444654d96f0aad962f7be4e541e" +checksum = "f002c58d4cc31a7b348b4a1e52a488a1958c6e92dac105ebb93f86484edd9c97" dependencies = [ - "base64 0.21.5", + "base64 0.21.7", "cosmrs", "cosmwasm-std", - "prost 0.12.3", - "serde 1.0.197", - "serde_json 1.0.111", + "prost 0.12.6", + "serde 1.0.203", + "serde_json 1.0.118", "tendermint-proto 0.32.2", "thiserror", ] @@ -3208,22 +3147,22 @@ checksum = "23d434d3f8967a09480fb04132ebe0a3e088c173e6d0ee7897abbdf4eab0f8b9" [[package]] name = "thiserror" -version = "1.0.60" +version = "1.0.61" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "579e9083ca58dd9dcf91a9923bb9054071b9ebbd800b342194c9feb0ee89fc18" +checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.60" +version = "1.0.61" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2470041c06ec3ac1ab38d0356a6119054dedaea53e12fbefc0de730a1c08524" +checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533" dependencies = [ "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", ] [[package]] @@ -3235,7 +3174,7 @@ dependencies = [ "deranged", "num-conv", "powerfmt", - "serde 1.0.202", + "serde 1.0.203", "time-core", "time-macros", ] @@ -3267,9 +3206,9 @@ dependencies = [ [[package]] name = "tinyvec" -version = "1.6.0" +version = "1.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50" +checksum = "c55115c6fbe2d2bef26eb09ad74bde02d8255476fc0c7b515ef09fbb35742d82" dependencies = [ "tinyvec_macros", ] @@ -3282,9 +3221,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" [[package]] name = "tokio" -version = "1.37.0" +version = "1.38.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787" +checksum = "ba4f4a02a7a80d6f274636f0aa95c7e383b912d41fe721a31f29e29698585a4a" dependencies = [ "backtrace", "bytes", @@ -3299,13 +3238,13 @@ dependencies = [ [[package]] name = "tokio-macros" -version = "2.2.0" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b" +checksum = "5f5ae998a069d4b5aba8ee9dad856af7d520c3699e6159b185c2acd48155d39a" dependencies = [ "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", ] [[package]] @@ -3337,7 +3276,7 @@ version = "0.5.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234" dependencies = [ - "serde 1.0.202", + "serde 1.0.203", ] [[package]] @@ -3430,9 +3369,9 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" [[package]] name = "url" -version = "2.5.0" +version = "2.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633" +checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c" dependencies = [ "form_urlencoded", "idna", @@ -3441,9 +3380,9 @@ dependencies = [ [[package]] name = "uuid" -version = "1.8.0" +version = "1.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0" +checksum = "5de17fd2f7da591098415cff336e12965a28061ddace43b59cb3c430179c9439" [[package]] name = "version_check" @@ -3497,25 +3436,13 @@ dependencies = [ "once_cell", "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-futures" -version = "0.4.39" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac36a15a220124ac510204aec1c3e5db8a22ab06fd6706d881dc6149f8ed9a12" -dependencies = [ - "cfg-if", - "js-sys", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.89" +version = "0.4.42" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0" dependencies = [ @@ -3543,7 +3470,7 @@ checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -3765,21 +3692,11 @@ dependencies = [ "windows-sys 0.48.0", ] -[[package]] -name = "winreg" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" -dependencies = [ - "cfg-if", - "windows-sys 0.48.0", -] - [[package]] name = "zeroize" -version = "1.7.0" +version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d" +checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde" dependencies = [ "zeroize_derive", ] @@ -3792,5 +3709,5 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" dependencies = [ "proc-macro2", "quote", - "syn 2.0.64", + "syn 2.0.68", ] diff --git a/contracts/atomic-order-example/Cargo.toml b/contracts/atomic-order-example/Cargo.toml index 4a2ab553..f05f7fb8 100644 --- a/contracts/atomic-order-example/Cargo.toml +++ b/contracts/atomic-order-example/Cargo.toml @@ -34,9 +34,9 @@ cosmwasm-storage = { version = "1.5.0", features = [ "iterator" ] } cw-storage-plus = { version = "1.2.0" } cw-utils = { version = "0.16.0" } cw2 = { version = "0.16.0" } -injective-cosmwasm = { version = "0.2.23-rc1", path = "../../packages/injective-cosmwasm" } -injective-math = { version = "0.2.4", path = "../../packages/injective-math" } -injective-protobuf = { version = "0.2.2", path = "../../packages/injective-protobuf" } +injective-cosmwasm = { path = "../../packages/injective-cosmwasm" } +injective-math = { path = "../../packages/injective-math" } +injective-protobuf = { path = "../../packages/injective-protobuf" } protobuf = { version = "2.28.0", features = [ "with-bytes" ] } schemars = { version = "0.8.8", features = [ "enumset" ] } serde = { version = "1.0.137", default-features = false, features = [ "derive" ] } diff --git a/contracts/dummy/Cargo.toml b/contracts/dummy/Cargo.toml index 53f58500..cf3adba5 100644 --- a/contracts/dummy/Cargo.toml +++ b/contracts/dummy/Cargo.toml @@ -32,7 +32,7 @@ optimize = """docker run --rm -v "$(pwd)":/code \ cosmwasm-std = { version = "1.5.0", features = [ "abort", "cosmwasm_1_2", "cosmwasm_1_3", "cosmwasm_1_4", "iterator", "stargate" ] } cw-storage-plus = { version = "1.2.0" } cw2 = { version = "0.16.0" } -injective-cosmwasm = { version = "0.2.23-rc1", path = "../../packages/injective-cosmwasm" } +injective-cosmwasm = { path = "../../packages/injective-cosmwasm" } schemars = "0.8.8" serde = { version = "1.0.136", default-features = false, features = [ "derive" ] } thiserror = { version = "1.0.30" } diff --git a/contracts/injective-cosmwasm-mock/Cargo.toml b/contracts/injective-cosmwasm-mock/Cargo.toml index d3144b11..616a4971 100644 --- a/contracts/injective-cosmwasm-mock/Cargo.toml +++ b/contracts/injective-cosmwasm-mock/Cargo.toml @@ -47,5 +47,5 @@ thiserror = { version = "1.0.56" } [dev-dependencies] injective-std = { path = "../../packages/injective-std" } -injective-test-tube = { path = "/Users/markuswaas/work/injective/test-tube/packages/injective-test-tube" } -injective-testing = { version = "0.1.6" } +injective-test-tube = { git = "https://github.com/InjectiveLabs/test-tube", package = "injective-test-tube", branch = "latest" } +injective-testing = { path = "../../packages/injective-testing" } diff --git a/contracts/injective-cosmwasm-stargate-example/Cargo.toml b/contracts/injective-cosmwasm-stargate-example/Cargo.toml index ca7eaa6e..b6df406e 100644 --- a/contracts/injective-cosmwasm-stargate-example/Cargo.toml +++ b/contracts/injective-cosmwasm-stargate-example/Cargo.toml @@ -49,5 +49,5 @@ thiserror = { version = "1.0.56" } [dev-dependencies] injective-std = { path = "../../packages/injective-std" } -injective-test-tube = { path = "/Users/markuswaas/work/injective/test-tube/packages/injective-test-tube" } -injective-testing = { version = "0.1.6" } +injective-test-tube = { git = "https://github.com/InjectiveLabs/test-tube", package = "injective-test-tube", branch = "latest" } +injective-testing = { path = "../../packages/injective-testing" } diff --git a/packages/injective-testing/Cargo.toml b/packages/injective-testing/Cargo.toml index 2c2c2031..09adcb90 100644 --- a/packages/injective-testing/Cargo.toml +++ b/packages/injective-testing/Cargo.toml @@ -12,7 +12,7 @@ anyhow = { version = "1.0.66" } base64 = { version = "0.13.1" } cosmwasm-std = { version = "1.5.0", features = [ "abort", "cosmwasm_1_2", "cosmwasm_1_3", "cosmwasm_1_4", "iterator", "stargate" ] } cw-multi-test = { version = "0.16.2" } -injective-cosmwasm = { version = "0.2.23-rc1", path = "../injective-cosmwasm" } +injective-cosmwasm = { path = "../../packages/injective-cosmwasm" } injective-math = { version = "0.2.4", path = "../injective-math" } rand = { version = "0.4.6" } secp256k1 = { version = "0.6.2" } From a8c5aeeb3e3be2de1dab22fd973a0c9c1e12dd1e Mon Sep 17 00:00:00 2001 From: Markus Waas Date: Fri, 28 Jun 2024 12:26:30 +0200 Subject: [PATCH 11/19] feat: add more stargate examples --- contracts/atomic-order-example/src/tests.rs | 1 + .../injective-cosmwasm-mock/src/contract.rs | 2 +- .../injective-cosmwasm-mock/src/handle.rs | 1 + .../src/testing/test_exchange.rs | 2 + .../src/testing/test_exchange_derivative.rs | 2 + .../injective-cosmwasm-mock/src/utils.rs | 2 + .../src/contract.rs | 14 +++-- .../src/handle.rs | 25 +++++++++ .../src/lib.rs | 1 + .../src/msg.rs | 10 +++- .../src/query.rs | 15 +++++- .../src/reply.rs | 6 +-- .../src/spot_market_order_msg.rs | 54 +++++++++++++++++++ .../src/testing/test_auction.rs | 6 +-- .../src/testing/test_auth.rs | 4 +- .../src/testing/test_bank.rs | 27 +++++++--- .../src/testing/test_exchange.rs | 34 ++++++++++-- .../src/testing/test_exchange_derivative.rs | 16 +++--- .../src/testing/test_oracle.rs | 8 ++- .../src/utils.rs | 4 +- 20 files changed, 195 insertions(+), 39 deletions(-) create mode 100644 contracts/injective-cosmwasm-stargate-example/src/spot_market_order_msg.rs diff --git a/contracts/atomic-order-example/src/tests.rs b/contracts/atomic-order-example/src/tests.rs index 7dc618c7..1f39b916 100644 --- a/contracts/atomic-order-example/src/tests.rs +++ b/contracts/atomic-order-example/src/tests.rs @@ -136,6 +136,7 @@ fn create_spot_market_handler() -> impl HandlesMarketIdQuery { status: MarketStatus::Active, min_price_tick_size: FPDecimal::from_str("0.000000000000001").unwrap(), min_quantity_tick_size: FPDecimal::from_str("1000000000000000").unwrap(), + min_notional: FPDecimal::ONE, }), }; SystemResult::Ok(ContractResult::from(to_json_binary(&response))) diff --git a/contracts/injective-cosmwasm-mock/src/contract.rs b/contracts/injective-cosmwasm-mock/src/contract.rs index 22e36d97..9ca4263f 100644 --- a/contracts/injective-cosmwasm-mock/src/contract.rs +++ b/contracts/injective-cosmwasm-mock/src/contract.rs @@ -1,6 +1,6 @@ use crate::{ error::ContractError, - handle::{handle_test_transient_derivative_order, handle_test_transient_spot_order}, + handle::{handle_test_market_spot_order, handle_test_transient_derivative_order, handle_test_transient_spot_order}, msg::{ExecuteMsg, InstantiateMsg, QueryMsg}, query::{ handle_aggregate_account_volume_query, handle_aggregate_market_volume_query, handle_contract_registration_info_query, diff --git a/contracts/injective-cosmwasm-mock/src/handle.rs b/contracts/injective-cosmwasm-mock/src/handle.rs index 39f6e40d..82caa25d 100644 --- a/contracts/injective-cosmwasm-mock/src/handle.rs +++ b/contracts/injective-cosmwasm-mock/src/handle.rs @@ -2,6 +2,7 @@ use crate::{ contract::{CREATE_DERIVATIVE_ORDER_REPLY_ID, CREATE_SPOT_ORDER_REPLY_ID, MSG_EXEC}, msg::{MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT, MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT}, order_management::{create_derivative_limit_order, create_spot_limit_order, create_stargate_msg, encode_bytes_message}, + spot_market_order_msg::create_spot_market_order_message, state::{CacheOrderInfo, ORDER_CALL_CACHE}, ContractError, }; diff --git a/contracts/injective-cosmwasm-mock/src/testing/test_exchange.rs b/contracts/injective-cosmwasm-mock/src/testing/test_exchange.rs index 9db7b659..506296c7 100644 --- a/contracts/injective-cosmwasm-mock/src/testing/test_exchange.rs +++ b/contracts/injective-cosmwasm-mock/src/testing/test_exchange.rs @@ -148,6 +148,7 @@ fn test_query_spot_market() { let ticker = "INJ/USDT".to_string(); let min_price_tick_size = FPDecimal::must_from_str("0.000000000000001"); let min_quantity_tick_size = FPDecimal::must_from_str("1000000000000000"); + let min_notional = FPDecimal::must_from_str("1"); exchange .instant_spot_market_launch( @@ -158,6 +159,7 @@ fn test_query_spot_market() { quote_denom: QUOTE_DENOM.to_string(), min_price_tick_size: dec_to_proto(min_price_tick_size), min_quantity_tick_size: dec_to_proto(min_quantity_tick_size), + min_notional: dec_to_proto(min_notional), }, &env.signer, ) diff --git a/contracts/injective-cosmwasm-mock/src/testing/test_exchange_derivative.rs b/contracts/injective-cosmwasm-mock/src/testing/test_exchange_derivative.rs index f5f42516..a9480c2d 100644 --- a/contracts/injective-cosmwasm-mock/src/testing/test_exchange_derivative.rs +++ b/contracts/injective-cosmwasm-mock/src/testing/test_exchange_derivative.rs @@ -49,6 +49,7 @@ fn test_query_derivative_market() { let maintenance_margin_ratio = FPDecimal::must_from_str("0.05"); let min_price_tick_size = FPDecimal::must_from_str("1000.0"); let min_quantity_tick_size = FPDecimal::must_from_str("1000000000000000"); + let min_notional = FPDecimal::must_from_str("1"); let quote_denom = QUOTE_DENOM.to_string(); let maker_fee_rate = FPDecimal::ZERO; let taker_fee_rate = FPDecimal::ZERO; @@ -69,6 +70,7 @@ fn test_query_derivative_market() { maintenance_margin_ratio: dec_to_proto(maintenance_margin_ratio), min_price_tick_size: dec_to_proto(min_price_tick_size), min_quantity_tick_size: dec_to_proto(min_quantity_tick_size), + min_notional: dec_to_proto(min_notional), }, &env.signer, ) diff --git a/contracts/injective-cosmwasm-mock/src/utils.rs b/contracts/injective-cosmwasm-mock/src/utils.rs index a3ce3efb..53cc8649 100644 --- a/contracts/injective-cosmwasm-mock/src/utils.rs +++ b/contracts/injective-cosmwasm-mock/src/utils.rs @@ -326,6 +326,7 @@ pub fn launch_spot_market(exchange: &Exchange, signer: &Signin quote_denom: QUOTE_DENOM.to_string(), min_price_tick_size: dec_to_proto(FPDecimal::must_from_str("0.000000000000001")), min_quantity_tick_size: dec_to_proto(FPDecimal::must_from_str("1")), + min_notional: dec_to_proto(FPDecimal::must_from_str("1")), }, signer, ) @@ -364,6 +365,7 @@ pub fn launch_perp_market(exchange: &Exchange, signer: &Signin maintenance_margin_ratio: "50000000000000000".to_owned(), min_price_tick_size: "1000000000000000000000".to_owned(), min_quantity_tick_size: "1000000000000000".to_owned(), + min_notional: dec_to_proto(FPDecimal::must_from_str("1")), }, signer, ) diff --git a/contracts/injective-cosmwasm-stargate-example/src/contract.rs b/contracts/injective-cosmwasm-stargate-example/src/contract.rs index aec4b87a..3e23266a 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/contract.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/contract.rs @@ -1,8 +1,8 @@ use crate::{ error::ContractError, - handle::{handle_test_transient_derivative_order, handle_test_transient_spot_order}, + handle::{handle_test_market_spot_order, handle_test_transient_derivative_order, handle_test_transient_spot_order}, msg::{ExecuteMsg, InstantiateMsg, QueryMsg}, - query::handle_query_stargate, + query::{handle_query_bank_params, handle_query_spot_market, handle_query_stargate_raw}, reply::{handle_create_derivative_order_reply_stargate, handle_create_order_reply_stargate}, }; use cosmwasm_std::{entry_point, Binary, Deps, DepsMut, Env, MessageInfo, Reply, Response, StdResult}; @@ -34,6 +34,12 @@ pub fn execute( price, quantity, } => handle_test_transient_spot_order(deps, env, &info, market_id, subaccount_id, price, quantity), + ExecuteMsg::TestMarketOrderStargate { + market_id, + subaccount_id, + price, + quantity, + } => handle_test_market_spot_order(deps, env.contract.address.as_str(), market_id, subaccount_id, price, quantity), ExecuteMsg::TestTraderTransientDerivativeOrders { market_id, subaccount_id, @@ -47,7 +53,9 @@ pub fn execute( #[cfg_attr(not(feature = "library"), entry_point)] pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult { match msg { - QueryMsg::QueryStargate { path, query_request } => handle_query_stargate(&deps.querier, path, query_request), + QueryMsg::QueryStargateRaw { path, query_request } => handle_query_stargate_raw(&deps.querier, path, query_request), + QueryMsg::QueryBankParams {} => handle_query_bank_params(deps), + QueryMsg::QuerySpotMarket { market_id } => handle_query_spot_market(deps, &market_id), } } diff --git a/contracts/injective-cosmwasm-stargate-example/src/handle.rs b/contracts/injective-cosmwasm-stargate-example/src/handle.rs index db93e335..8c6bdc0d 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/handle.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/handle.rs @@ -2,6 +2,7 @@ use crate::{ contract::{CREATE_DERIVATIVE_ORDER_REPLY_ID, CREATE_SPOT_ORDER_REPLY_ID}, msg::{MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT, MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT}, order_management::{create_derivative_limit_order, create_spot_limit_order, create_stargate_msg, encode_bytes_message}, + spot_market_order_msg::create_spot_market_order_message, state::{CacheOrderInfo, ORDER_CALL_CACHE}, ContractError, }; @@ -12,6 +13,30 @@ use injective_math::{scale::Scaled, FPDecimal}; pub const MSG_EXEC: &str = "/cosmos.authz.v1beta1.MsgExec"; +pub fn handle_test_market_spot_order( + deps: DepsMut, + sender: &str, + market_id: MarketId, + subaccount_id: SubaccountId, + price: String, + quantity: String, +) -> Result, ContractError> { + let querier = InjectiveQuerier::new(&deps.querier); + let spot_market = querier.query_spot_market(&market_id).unwrap().market.unwrap(); + + let order_msg = create_spot_market_order_message( + FPDecimal::must_from_str(price.as_str()), + FPDecimal::must_from_str(quantity.as_str()), + OrderType::Sell, + sender, + subaccount_id.as_str(), + "", + &spot_market, + )?; + + Ok(Response::new().add_message(order_msg)) +} + pub fn handle_test_transient_spot_order( deps: DepsMut, env: Env, diff --git a/contracts/injective-cosmwasm-stargate-example/src/lib.rs b/contracts/injective-cosmwasm-stargate-example/src/lib.rs index 44ab7abb..39968d45 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/lib.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/lib.rs @@ -6,6 +6,7 @@ pub mod msg; mod order_management; mod query; mod reply; +mod spot_market_order_msg; mod state; #[cfg(test)] mod testing; diff --git a/contracts/injective-cosmwasm-stargate-example/src/msg.rs b/contracts/injective-cosmwasm-stargate-example/src/msg.rs index 4efaae39..b3f913ee 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/msg.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/msg.rs @@ -25,12 +25,20 @@ pub enum ExecuteMsg { quantity: String, margin: String, }, + TestMarketOrderStargate { + market_id: MarketId, + subaccount_id: SubaccountId, + price: String, + quantity: String, + }, } #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] #[serde(rename_all = "snake_case")] pub enum QueryMsg { - QueryStargate { path: String, query_request: String }, + QueryStargateRaw { path: String, query_request: String }, + QueryBankParams {}, + QuerySpotMarket { market_id: String }, } #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] diff --git a/contracts/injective-cosmwasm-stargate-example/src/query.rs b/contracts/injective-cosmwasm-stargate-example/src/query.rs index 807d27c3..5ac86cd9 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/query.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/query.rs @@ -1,10 +1,11 @@ use crate::msg::QueryStargateResponse; use base64::engine::general_purpose::STANDARD as BASE64_STANDARD; use base64::Engine as _; -use cosmwasm_std::{to_json_binary, to_json_vec, Binary, ContractResult, QuerierWrapper, QueryRequest, StdError, StdResult, SystemResult}; +use cosmwasm_std::{to_json_binary, to_json_vec, Binary, ContractResult, Deps, QuerierWrapper, QueryRequest, StdError, StdResult, SystemResult}; use injective_cosmwasm::InjectiveQueryWrapper; +use injective_std::types::{cosmos::bank::v1beta1::BankQuerier, injective::exchange::v1beta1::ExchangeQuerier}; -pub fn handle_query_stargate(querier: &QuerierWrapper, path: String, query_request: String) -> StdResult { +pub fn handle_query_stargate_raw(querier: &QuerierWrapper, path: String, query_request: String) -> StdResult { let data = Binary::from_base64(&query_request)?; let request = &QueryRequest::::Stargate { path, data }; let raw = to_json_vec(request).map_err(|serialize_err| StdError::generic_err(format!("Serializing QueryRequest: {}", serialize_err)))?; @@ -23,3 +24,13 @@ pub fn handle_query_stargate(querier: &QuerierWrapper, pa value: String::from_utf8(decoded_value)?, }) } + +pub fn handle_query_spot_market(deps: Deps, market_id: &str) -> StdResult { + let querier = ExchangeQuerier::new(&deps.querier); + to_json_binary(&querier.spot_market(market_id.to_string())?) +} + +pub fn handle_query_bank_params(deps: Deps) -> StdResult { + let querier = BankQuerier::new(&deps.querier); + to_json_binary(&querier.params()?) +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/reply.rs b/contracts/injective-cosmwasm-stargate-example/src/reply.rs index 02455269..17f076ad 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/reply.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/reply.rs @@ -1,4 +1,4 @@ -use crate::{encode_helper::encode_proto_message, query::handle_query_stargate, state::ORDER_CALL_CACHE, ContractError}; +use crate::{encode_helper::encode_proto_message, query::handle_query_stargate_raw, state::ORDER_CALL_CACHE, ContractError}; use cosmwasm_std::{DepsMut, Event, Reply, Response}; use injective_cosmwasm::InjectiveQueryWrapper; @@ -37,7 +37,7 @@ pub fn handle_create_order_reply_stargate(deps: DepsMut, market_id: order_info.market_id.clone().into(), subaccount_id: order_info.subaccount.clone().into(), }); - let stargate_response = handle_query_stargate( + let stargate_response = handle_query_stargate_raw( &deps.querier, "/injective.exchange.v1beta1.Query/TraderSpotTransientOrders".to_string(), encode_query_message, @@ -64,7 +64,7 @@ pub fn handle_create_derivative_order_reply_stargate(deps: DepsMut StdResult> { + let msg = create_spot_market_order(price, quantity, order_type, sender, subaccount_id, fee_recipient, market); + + let mut order_bytes = vec![]; + Exchange::MsgCreateSpotMarketOrder::encode(&msg, &mut order_bytes).unwrap(); + + Ok(CosmosMsg::Stargate { + type_url: Exchange::MsgCreateSpotMarketOrder::TYPE_URL.to_string(), + value: order_bytes.into(), + }) +} + +fn create_spot_market_order( + price: FPDecimal, + quantity: FPDecimal, + order_type: OrderType, + sender: &str, + subaccount_id: &str, + fee_recipient: &str, + market: &SpotMarket, +) -> Exchange::MsgCreateSpotMarketOrder { + let rounded_quantity = round_to_min_tick(quantity, market.min_quantity_tick_size); + let rounded_price = round_to_nearest_tick(price, market.min_price_tick_size); + + Exchange::MsgCreateSpotMarketOrder { + sender: sender.to_string(), + order: Some(Exchange::SpotOrder { + market_id: market.market_id.as_str().into(), + order_info: Some(Exchange::OrderInfo { + subaccount_id: subaccount_id.to_string(), + fee_recipient: fee_recipient.to_string(), + price: rounded_price.to_proto_string(), + quantity: rounded_quantity.to_proto_string(), + cid: "".to_string(), + }), + order_type: order_type as i32, + trigger_price: "".to_string(), + }), + } +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_auction.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_auction.rs index fbd7dc38..544b8c03 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_auction.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_auction.rs @@ -48,7 +48,7 @@ pub struct LastAuctionResult { fn test_current_auction_basket() { let env = Setup::new(ExchangeType::None); let wasm = Wasm::new(&env.app); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.auction.v1beta1.Query/CurrentAuctionBasket".to_string(), query_request: "".to_string(), }; @@ -69,7 +69,7 @@ fn test_current_auction_basket() { fn test_auction_params() { let env = Setup::new(ExchangeType::None); let wasm = Wasm::new(&env.app); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.auction.v1beta1.Query/AuctionParams".to_string(), query_request: "".to_string(), }; @@ -87,7 +87,7 @@ fn test_auction_params() { fn test_last_auction_result() { let env = Setup::new(ExchangeType::None); let wasm = Wasm::new(&env.app); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.auction.v1beta1.Query/LastAuctionResult".to_string(), query_request: "".to_string(), }; diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_auth.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_auth.rs index dc5bf2e0..6bf84b1a 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_auth.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_auth.rs @@ -12,7 +12,7 @@ use injective_test_tube::{Account, Module, Wasm}; fn test_query_auth_params() { let env = Setup::new(ExchangeType::None); let wasm = Wasm::new(&env.app); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/cosmos.auth.v1beta1.Query/Params".to_string(), query_request: "".to_string(), }; @@ -30,7 +30,7 @@ fn test_query_auth_account() { let wasm = Wasm::new(&env.app); let user_address = env.users[0].account.address().to_string(); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/cosmos.auth.v1beta1.Query/Account".to_string(), query_request: encode_proto_message(QueryAccountRequest { address: user_address.to_owned(), diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs index 3e4280fe..bd6f4c71 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs @@ -1,20 +1,31 @@ use crate::{ encode_helper::encode_proto_message, msg::{QueryMsg, QueryStargateResponse}, - testing::type_helpers::{BankParams, ParamResponse, QueryBalanceResponse, QuerySupplyOffResponse, QueryDenomMetadataResponse}, + testing::type_helpers::{BankParams, ParamResponse, QueryBalanceResponse, QueryDenomMetadataResponse, QuerySupplyOffResponse}, utils::{ExchangeType, Setup}, }; use cosmos_sdk_proto::cosmos::bank::v1beta1::{QueryBalanceRequest, QueryDenomMetadataRequest, QuerySupplyOfRequest}; use cosmwasm_std::{Coin, Uint128}; -use injective_test_tube::{Account, Module, TokenFactory, Wasm}; use injective_std::types::injective::tokenfactory::v1beta1::MsgCreateDenom; +use injective_test_tube::{Account, Module, TokenFactory, Wasm}; #[test] #[cfg_attr(not(feature = "integration"), ignore)] fn test_query_bank_params() { let env = Setup::new(ExchangeType::None); let wasm = Wasm::new(&env.app); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryBankParams {}; + + let contract_response: ParamResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + assert!(contract_response.params.default_send_enabled); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_bank_params_raw() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + let query_msg = QueryMsg::QueryStargateRaw { path: "/cosmos.bank.v1beta1.Query/Params".to_string(), query_request: "".to_string(), }; @@ -22,7 +33,7 @@ fn test_query_bank_params() { let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); let contract_response = contract_response.value; let response: ParamResponse = serde_json::from_str(&contract_response).unwrap(); - assert_eq!(response.params.default_send_enabled, true); + assert!(response.params.default_send_enabled); } #[test] @@ -35,11 +46,13 @@ fn test_query_denom_metadata() { let create_denom_msg = MsgCreateDenom { sender: env.users[0].account.address().to_string(), subdenom: "cw".to_string(), + name: "CosmWasm".to_string(), + symbol: "CW".to_string(), }; let denom = token_factory.create_denom(create_denom_msg, &env.users[0].account).unwrap(); let denom_name = denom.data.new_token_denom; - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/cosmos.bank.v1beta1.Query/DenomMetadata".to_string(), query_request: encode_proto_message(QueryDenomMetadataRequest { denom: denom_name.to_owned(), @@ -58,7 +71,7 @@ fn test_query_bank_balance() { let env = Setup::new(ExchangeType::None); let wasm = Wasm::new(&env.app); let user_address = env.users[0].account.address().to_string(); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/cosmos.bank.v1beta1.Query/Balance".to_string(), query_request: encode_proto_message(QueryBalanceRequest { address: user_address.to_owned(), @@ -83,7 +96,7 @@ fn test_query_bank_balance() { fn test_query_supply_of() { let env = Setup::new(ExchangeType::None); let wasm = Wasm::new(&env.app); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/cosmos.bank.v1beta1.Query/SupplyOf".to_string(), query_request: encode_proto_message(QuerySupplyOfRequest { denom: "inj".to_string() }), }; diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs index d002291b..72087e59 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange.rs @@ -7,7 +7,7 @@ use crate::{ ExchangeType, Setup, BASE_DECIMALS, BASE_DENOM, QUOTE_DECIMALS, }, }; -use cosmwasm_std::{from_json, Addr}; +use cosmwasm_std::{from_json, Addr, Coin}; use injective_cosmwasm::{checked_address_to_subaccount_id, MarketId, SubaccountDepositResponse}; use injective_std::types::injective::exchange::v1beta1::{Deposit, MsgDeposit, QuerySubaccountDepositRequest, QuerySubaccountDepositsRequest}; use injective_test_tube::{Account, Exchange, Module, Wasm}; @@ -18,7 +18,7 @@ fn test_exchange_param() { let env = Setup::new(ExchangeType::None); let wasm = Wasm::new(&env.app); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.exchange.v1beta1.Query/QueryExchangeParams".to_string(), query_request: "".to_string(), }; @@ -82,7 +82,7 @@ fn test_query_subaccount_deposit() { } ); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.exchange.v1beta1.Query/SubaccountDeposit".to_string(), query_request: encode_proto_message(QuerySubaccountDepositRequest { subaccount_id: subaccount_id.to_string(), @@ -134,3 +134,31 @@ fn test_query_trader_transient_spot_orders() { let expected_order_info = "{\"value\":\"{\\\"orders\\\":[{\\\"price\\\":\\\"0.000000000009800000\\\",\\\"quantity\\\":\\\"1000000000000000000.000000000000000000\\\",\\\"fillable\\\":\\\"1000000000000000000.000000000000000000\\\",\\\"isBuy\\\":false,"; assert!(transient_query.unwrap().value.contains(expected_order_info)); } + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_trader_spot_market_order() { + let env = Setup::new(ExchangeType::Spot); + let wasm = Wasm::new(&env.app); + let market_id = env.market_id.unwrap(); + + let subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(env.contract_address.to_owned()), 0u32); + + execute_all_authorizations(&env.app, &env.users[0].account, env.contract_address.clone()); + add_spot_initial_liquidity(&env.app, market_id.clone()); + + let (scale_price, scale_quantity) = scale_price_quantity_for_spot_market_dec("9.8", "1", &BASE_DECIMALS, "E_DECIMALS); + + wasm.execute( + &env.contract_address, + &ExecuteMsg::TestMarketOrderStargate { + market_id: MarketId::new(market_id).unwrap(), + subaccount_id: subaccount_id.clone(), + price: scale_price.to_string(), + quantity: scale_quantity.to_string(), + }, + &[Coin::new(1000000000000000000000, "inj")], + &env.users[0].account, + ) + .unwrap(); +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange_derivative.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange_derivative.rs index 2db473a4..26f46fb9 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange_derivative.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_exchange_derivative.rs @@ -32,7 +32,7 @@ fn test_query_perpetual_market_info() { let derivative_market_id = get_perpetual_market_id(&exchange, ticker.to_owned()); let market_id = MarketId::new(derivative_market_id.clone()).unwrap(); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.exchange.v1beta1.Query/PerpetualMarketInfo".to_string(), query_request: encode_proto_message(QueryPerpetualMarketInfoRequest { market_id: market_id.to_owned().into(), @@ -86,7 +86,7 @@ fn test_query_derivative_market() { .unwrap(); let derivative_market_id = get_perpetual_market_id(&exchange, ticker.to_owned()); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.exchange.v1beta1.Query/DerivativeMarket".to_string(), query_request: encode_proto_message(QueryDerivativeMarketRequest { market_id: derivative_market_id.to_owned(), @@ -130,7 +130,7 @@ fn test_query_effective_subaccount_position() { margin, ); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.exchange.v1beta1.Query/SubaccountEffectivePositionInMarket".to_string(), query_request: encode_proto_message(QuerySubaccountEffectivePositionInMarketRequest { market_id: market_id.to_owned(), @@ -167,7 +167,7 @@ fn test_query_vanilla_subaccount_position() { margin, ); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.exchange.v1beta1.Query/SubaccountPositionInMarket".to_string(), query_request: encode_proto_message(QuerySubaccountPositionInMarketRequest { subaccount_id: subaccount_id.to_string(), @@ -214,7 +214,7 @@ fn test_query_trader_derivative_orders() { margin, ); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.exchange.v1beta1.Query/TraderDerivativeOrders".to_string(), query_request: encode_proto_message(QueryTraderDerivativeOrdersRequest { subaccount_id: subaccount_id.to_string(), @@ -250,7 +250,7 @@ fn test_query_perpetual_market_funding() { let exchange = Exchange::new(&env.app); let ticker = "INJ/USDT".to_string(); let derivative_market_id = get_perpetual_market_id(&exchange, ticker.to_owned()); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.exchange.v1beta1.Query/PerpetualMarketFunding".to_string(), query_request: encode_proto_message(QueryPerpetualMarketFundingRequest { market_id: derivative_market_id.to_owned(), @@ -271,7 +271,7 @@ fn test_query_derivative_market_mid_price_and_tob() { let market_id = env.market_id.unwrap(); add_perp_initial_liquidity(&env.app, market_id.to_owned()); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.exchange.v1beta1.Query/DerivativeMidPriceAndTOB".to_string(), query_request: encode_proto_message(QueryDerivativeMidPriceAndTobRequest { market_id: market_id.to_owned(), @@ -293,7 +293,7 @@ fn test_query_derivative_market_orderbook() { let liquidity_orders = get_initial_perp_liquidity_orders_vector(); add_derivative_orders(&env.app, market_id.clone(), liquidity_orders.to_owned(), None); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.exchange.v1beta1.Query/DerivativeOrderbook".to_string(), query_request: encode_proto_message(QueryDerivativeOrderbookRequest { market_id: market_id.to_owned(), diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_oracle.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_oracle.rs index c6ebf71c..2efe2651 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_oracle.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_oracle.rs @@ -21,7 +21,7 @@ fn test_query_oracle_price() { let wasm = Wasm::new(&env.app); let oracle = Oracle::new(&env.app); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.oracle.v1beta1.Query/OraclePrice".to_string(), query_request: encode_proto_message(QueryOraclePriceRequest { oracle_type: OracleType::PriceFeed as i32, @@ -59,13 +59,11 @@ fn test_query_oracle_volatility() { let base_info = Some(OracleInfo { symbol: env.denoms["base"].to_owned(), oracle_type: OracleType::PriceFeed as i32, - scale_factor: 6u32, }); let quote_info = Some(OracleInfo { symbol: env.denoms["quote"].to_owned(), oracle_type: OracleType::PriceFeed as i32, - scale_factor: 6u32, }); let oracle_history_options = Some(OracleHistoryOptions { @@ -74,7 +72,7 @@ fn test_query_oracle_volatility() { include_metadata: true, }); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.oracle.v1beta1.Query/OracleVolatility".to_string(), query_request: encode_proto_message(QueryOracleVolatilityRequest { base_info, @@ -108,7 +106,7 @@ fn test_query_pyth_oracle_price() { .unwrap(); let price_pyth_oracle_response = FPDecimal::must_from_str(price_pyth_oracle_response.price_state.unwrap().ema_price.as_str()); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/injective.oracle.v1beta1.Query/PythPrice".to_string(), query_request: encode_proto_message(QueryPythPriceRequest { price_id: INJ_PYTH_PRICE_ID.to_string(), diff --git a/contracts/injective-cosmwasm-stargate-example/src/utils.rs b/contracts/injective-cosmwasm-stargate-example/src/utils.rs index 2d65e8ae..ce9a3a22 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/utils.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/utils.rs @@ -416,6 +416,7 @@ pub fn add_spot_order_as(app: &InjectiveTestApp, market_id: String, trader: &Use fee_recipient: trader.account.address(), price, quantity, + cid: "".to_string(), }), order_type: order_type.into(), trigger_price: "".to_string(), @@ -541,6 +542,7 @@ pub fn add_derivative_order_as( fee_recipient: trader.address(), price, quantity, + cid: "".to_string(), }), margin, order_type: order_type.into(), @@ -838,7 +840,7 @@ pub fn create_some_usdt_price_attestation(human_price: &str, decimal_precision: pub fn get_stargate_query_result(contract_response: RunnerResult) -> serde_json::Result { let contract_response = contract_response.unwrap().value; serde_json::from_str::(&contract_response).map_err(|error| { - println!("{} \n {}", error.to_string(), contract_response); + println!("{} \n {}", error, contract_response); error }) } From ebf028078b142464c18f8059e3d3bea24caaf25e Mon Sep 17 00:00:00 2001 From: jbernal87 Date: Mon, 1 Jul 2024 16:50:03 +0200 Subject: [PATCH 12/19] feat: authz tests. --- .../src/testing/authz.rs | 150 ++++++++++++++++++ .../src/testing/mod.rs | 1 + .../src/testing/type_helpers.rs | 26 +++ 3 files changed, 177 insertions(+) create mode 100644 contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs new file mode 100644 index 00000000..db4a9a9a --- /dev/null +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs @@ -0,0 +1,150 @@ +use cosmos_sdk_proto::cosmos::authz::v1beta1::{QueryGranteeGrantsRequest, QueryGranterGrantsRequest, QueryGrantsRequest }; +use crate::{ + encode_helper::encode_proto_message, + msg::{QueryMsg, QueryStargateResponse}, + utils::{ + execute_all_authorizations, + ExchangeType, Setup, + }, +}; +use injective_test_tube::{Account, Module, RunnerResult, Wasm}; +use injective_test_tube::RunnerError::QueryError; + +use crate::testing::type_helpers::{Authorization, Grants, StargateQueryGranteeGrantsResponse, StargateQueryGranterGrantsResponse}; +use crate::utils::get_stargate_query_result; + + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_grantee_grants() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + + execute_all_authorizations(&env.app, &env.users[0].account, env.users[1].account.address().to_string()); + execute_all_authorizations(&env.app, &env.users[2].account, env.users[1].account.address().to_string()); + + let query_msg = QueryMsg::QueryStargate { + path: "/cosmos.authz.v1beta1.Query/GranteeGrants".to_string(), + query_request: encode_proto_message(QueryGranteeGrantsRequest { + grantee: env.users[1].account.address().to_string(), + pagination: None, + }), + }; + + let messages = vec![ + "/injective.exchange.v1beta1.MsgBatchUpdateOrders", + "/injective.exchange.v1beta1.MsgCreateDerivativeLimitOrder", + "/injective.exchange.v1beta1.MsgCreateDerivativeMarketOrder", + "/injective.exchange.v1beta1.MsgCreateSpotLimitOrder", + "/injective.exchange.v1beta1.MsgWithdraw", + ]; + + let response_user0 = create_stargate_response(messages.clone(), env.users[0].account.address().to_string(), env.users[1].account.address().to_string()); + let response_user2 = create_stargate_response(messages, env.users[2].account.address().to_string(), env.users[1].account.address().to_string()); + + let combined_grants = response_user0.grants.into_iter().chain(response_user2.grants.into_iter()).collect::>(); + let query_result = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + + let all_grants_present = combined_grants.iter().all(|grant| query_result.grants.contains(grant)); + let no_extra_grants = combined_grants.len() == query_result.grants.len(); + + assert!(all_grants_present); + assert!(no_extra_grants); +} + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_granter_grants() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + + execute_all_authorizations(&env.app, &env.users[0].account, env.users[1].account.address().to_string()); + + let query_msg = QueryMsg::QueryStargate { + path: "/cosmos.authz.v1beta1.Query/GranterGrants".to_string(), + query_request: encode_proto_message(QueryGranterGrantsRequest { + granter: env.users[0].account.address().to_string(), + pagination: None, + }), + }; + + let query_result = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + assert_eq!(query_result.grants.len(), 5); + + let query_msg = QueryMsg::QueryStargate { + path: "/cosmos.authz.v1beta1.Query/GranterGrants".to_string(), + query_request: encode_proto_message(QueryGranterGrantsRequest { + granter: env.users[2].account.address().to_string(), + pagination: None, + }), + }; + + let query_result = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + assert_eq!(query_result.grants.len(), 0); + +} + + +#[test] +#[cfg_attr(not(feature = "integration"), ignore)] +fn test_query_grants() { + let env = Setup::new(ExchangeType::None); + let wasm = Wasm::new(&env.app); + + execute_all_authorizations(&env.app, &env.users[0].account, env.users[1].account.address().to_string()); + + let query_msg = QueryMsg::QueryStargate { + path: "/cosmos.authz.v1beta1.Query/Grants".to_string(), + query_request: encode_proto_message(QueryGrantsRequest { + granter: env.users[0].account.address().to_string(), + grantee: env.users[1].account.address().to_string(), + msg_type_url: "/injective.exchange.v1beta1.MsgCreateDerivativeMarketOrder".to_string(), + pagination: None, + }), + }; + + let contract_response: QueryStargateResponse = wasm.query(&env.contract_address, &query_msg).unwrap(); + println!("{:?}", contract_response); + // let query_result = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); + // println!("{:?}", query_result); + + let query_msg = QueryMsg::QueryStargate { + path: "/cosmos.authz.v1beta1.Query/Grants".to_string(), + query_request: encode_proto_message(QueryGrantsRequest { + granter: env.users[2].account.address().to_string(), + grantee: env.users[1].account.address().to_string(), + msg_type_url: "/injective.exchange.v1beta1.MsgCreateDerivativeMarketOrder".to_string(), + pagination: None, + }), + }; + + let contract_response: RunnerResult = wasm.query(&env.contract_address, &query_msg); + println!("{:?}", contract_response); + + if let Err(QueryError { msg }) = contract_response { + assert_eq!( + msg, + "Generic error: Querier contract error: codespace: authz, code: 2: query wasm contract failed", + "The error message does not match the expected value" + ); + } else { + assert!(false, "Expected an error, but got a success: {:?}", contract_response); + } + + +} + +fn create_stargate_response(messages: Vec<&str>, granter: String, grantee: String) -> StargateQueryGranteeGrantsResponse { + let grants = messages.into_iter().map(|msg| { + Grants { + granter: granter.clone(), + grantee: grantee.clone(), + authorization: Authorization { + type_str: "/cosmos.authz.v1beta1.GenericAuthorization".to_string(), + msg: msg.to_string(), + }, + } + }).collect(); + + StargateQueryGranteeGrantsResponse { grants } +} \ No newline at end of file diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs index f79a70e5..972be7af 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs @@ -5,3 +5,4 @@ mod test_exchange; mod test_exchange_derivative; mod test_oracle; mod type_helpers; +mod authz; diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs index f7278c56..a72a6441 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs @@ -233,4 +233,30 @@ pub struct DenomUnit { #[derive(Serialize, Deserialize, Debug)] pub struct Pagination { // Define fields based on your pagination structure, if any +} + +#[derive(Serialize, Deserialize, Debug, PartialEq)] +pub struct StargateQueryGranteeGrantsResponse { + pub grants: Vec, +} + +#[derive(Serialize, Deserialize, Debug, PartialEq)] +pub struct StargateQueryGranterGrantsResponse { + pub grants: Vec, +} + + + +#[derive(Serialize, Deserialize, Debug, PartialEq)] +pub struct Grants { + pub granter: String, + pub grantee: String, + pub authorization: Authorization, +} + +#[derive(Serialize, Deserialize, Debug, PartialEq)] +pub struct Authorization { + #[serde(rename = "@type")] + pub type_str: String, + pub msg: String, } \ No newline at end of file From 825207d8a26c49f3b80d690893f9a14087cc244f Mon Sep 17 00:00:00 2001 From: jbernal87 Date: Mon, 1 Jul 2024 16:53:29 +0200 Subject: [PATCH 13/19] chore: lints. --- .../src/testing/authz.rs | 48 ++++++++++--------- .../src/testing/mod.rs | 2 +- .../src/testing/test_bank.rs | 4 +- .../src/testing/type_helpers.rs | 5 +- 4 files changed, 30 insertions(+), 29 deletions(-) diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs index db4a9a9a..7a994d37 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs @@ -1,19 +1,15 @@ -use cosmos_sdk_proto::cosmos::authz::v1beta1::{QueryGranteeGrantsRequest, QueryGranterGrantsRequest, QueryGrantsRequest }; use crate::{ encode_helper::encode_proto_message, msg::{QueryMsg, QueryStargateResponse}, - utils::{ - execute_all_authorizations, - ExchangeType, Setup, - }, + utils::{execute_all_authorizations, ExchangeType, Setup}, }; -use injective_test_tube::{Account, Module, RunnerResult, Wasm}; +use cosmos_sdk_proto::cosmos::authz::v1beta1::{QueryGranteeGrantsRequest, QueryGranterGrantsRequest, QueryGrantsRequest}; use injective_test_tube::RunnerError::QueryError; +use injective_test_tube::{Account, Module, RunnerResult, Wasm}; use crate::testing::type_helpers::{Authorization, Grants, StargateQueryGranteeGrantsResponse, StargateQueryGranterGrantsResponse}; use crate::utils::get_stargate_query_result; - #[test] #[cfg_attr(not(feature = "integration"), ignore)] fn test_query_grantee_grants() { @@ -39,10 +35,22 @@ fn test_query_grantee_grants() { "/injective.exchange.v1beta1.MsgWithdraw", ]; - let response_user0 = create_stargate_response(messages.clone(), env.users[0].account.address().to_string(), env.users[1].account.address().to_string()); - let response_user2 = create_stargate_response(messages, env.users[2].account.address().to_string(), env.users[1].account.address().to_string()); - - let combined_grants = response_user0.grants.into_iter().chain(response_user2.grants.into_iter()).collect::>(); + let response_user0 = create_stargate_response( + messages.clone(), + env.users[0].account.address().to_string(), + env.users[1].account.address().to_string(), + ); + let response_user2 = create_stargate_response( + messages, + env.users[2].account.address().to_string(), + env.users[1].account.address().to_string(), + ); + + let combined_grants = response_user0 + .grants + .into_iter() + .chain(response_user2.grants.into_iter()) + .collect::>(); let query_result = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); let all_grants_present = combined_grants.iter().all(|grant| query_result.grants.contains(grant)); @@ -81,10 +89,8 @@ fn test_query_granter_grants() { let query_result = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); assert_eq!(query_result.grants.len(), 0); - } - #[test] #[cfg_attr(not(feature = "integration"), ignore)] fn test_query_grants() { @@ -123,28 +129,26 @@ fn test_query_grants() { if let Err(QueryError { msg }) = contract_response { assert_eq!( - msg, - "Generic error: Querier contract error: codespace: authz, code: 2: query wasm contract failed", + msg, "Generic error: Querier contract error: codespace: authz, code: 2: query wasm contract failed", "The error message does not match the expected value" ); } else { assert!(false, "Expected an error, but got a success: {:?}", contract_response); } - - } fn create_stargate_response(messages: Vec<&str>, granter: String, grantee: String) -> StargateQueryGranteeGrantsResponse { - let grants = messages.into_iter().map(|msg| { - Grants { + let grants = messages + .into_iter() + .map(|msg| Grants { granter: granter.clone(), grantee: grantee.clone(), authorization: Authorization { type_str: "/cosmos.authz.v1beta1.GenericAuthorization".to_string(), msg: msg.to_string(), }, - } - }).collect(); + }) + .collect(); StargateQueryGranteeGrantsResponse { grants } -} \ No newline at end of file +} diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs index 972be7af..dbeede1a 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/mod.rs @@ -1,3 +1,4 @@ +mod authz; mod test_auction; mod test_auth; mod test_bank; @@ -5,4 +6,3 @@ mod test_exchange; mod test_exchange_derivative; mod test_oracle; mod type_helpers; -mod authz; diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs index e9cbdd00..8bf0ff28 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/test_bank.rs @@ -1,13 +1,13 @@ use crate::{ encode_helper::encode_proto_message, msg::{QueryMsg, QueryStargateResponse}, - testing::type_helpers::{BankParams, ParamResponse, QueryBalanceResponse, QuerySupplyOffResponse, QueryDenomMetadataResponse}, + testing::type_helpers::{BankParams, ParamResponse, QueryBalanceResponse, QueryDenomMetadataResponse, QuerySupplyOffResponse}, utils::{ExchangeType, Setup}, }; use cosmos_sdk_proto::cosmos::bank::v1beta1::{QueryBalanceRequest, QueryDenomMetadataRequest, QuerySupplyOfRequest}; use cosmwasm_std::{Coin, Uint128}; -use injective_test_tube::{Account, Module, TokenFactory, Wasm}; use injective_std::types::injective::tokenfactory::v1beta1::MsgCreateDenom; +use injective_test_tube::{Account, Module, TokenFactory, Wasm}; #[test] #[cfg_attr(not(feature = "integration"), ignore)] diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs index a72a6441..62d3c633 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs @@ -205,7 +205,6 @@ pub struct QuerySupplyOffResponse { pub amount: Coin, } - #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] pub struct QueryDenomMetadataResponse { pub metadatas: Vec, @@ -245,8 +244,6 @@ pub struct StargateQueryGranterGrantsResponse { pub grants: Vec, } - - #[derive(Serialize, Deserialize, Debug, PartialEq)] pub struct Grants { pub granter: String, @@ -259,4 +256,4 @@ pub struct Authorization { #[serde(rename = "@type")] pub type_str: String, pub msg: String, -} \ No newline at end of file +} From 42ab0c6cfdfda1ca4e69898feb1ad9ea9bd4af5e Mon Sep 17 00:00:00 2001 From: Kishan Dhakan Date: Sat, 27 Jul 2024 03:11:17 +0530 Subject: [PATCH 14/19] chore: fix compilation issue --- contracts/injective-cosmwasm-mock/src/contract.rs | 2 +- contracts/injective-cosmwasm-mock/src/handle.rs | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/contracts/injective-cosmwasm-mock/src/contract.rs b/contracts/injective-cosmwasm-mock/src/contract.rs index 9ca4263f..22e36d97 100644 --- a/contracts/injective-cosmwasm-mock/src/contract.rs +++ b/contracts/injective-cosmwasm-mock/src/contract.rs @@ -1,6 +1,6 @@ use crate::{ error::ContractError, - handle::{handle_test_market_spot_order, handle_test_transient_derivative_order, handle_test_transient_spot_order}, + handle::{handle_test_transient_derivative_order, handle_test_transient_spot_order}, msg::{ExecuteMsg, InstantiateMsg, QueryMsg}, query::{ handle_aggregate_account_volume_query, handle_aggregate_market_volume_query, handle_contract_registration_info_query, diff --git a/contracts/injective-cosmwasm-mock/src/handle.rs b/contracts/injective-cosmwasm-mock/src/handle.rs index 82caa25d..39f6e40d 100644 --- a/contracts/injective-cosmwasm-mock/src/handle.rs +++ b/contracts/injective-cosmwasm-mock/src/handle.rs @@ -2,7 +2,6 @@ use crate::{ contract::{CREATE_DERIVATIVE_ORDER_REPLY_ID, CREATE_SPOT_ORDER_REPLY_ID, MSG_EXEC}, msg::{MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT, MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT}, order_management::{create_derivative_limit_order, create_spot_limit_order, create_stargate_msg, encode_bytes_message}, - spot_market_order_msg::create_spot_market_order_message, state::{CacheOrderInfo, ORDER_CALL_CACHE}, ContractError, }; From 0d5be4eeb12c15f393a59f235f19b6746ee3d2ec Mon Sep 17 00:00:00 2001 From: maxrobot Date: Mon, 16 Sep 2024 16:38:08 +0100 Subject: [PATCH 15/19] fix: linters --- contracts/injective-cosmwasm-stargate-example/src/query.rs | 2 ++ .../src/testing/type_helpers.rs | 3 +-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/contracts/injective-cosmwasm-stargate-example/src/query.rs b/contracts/injective-cosmwasm-stargate-example/src/query.rs index e822591e..cb17e7cc 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/query.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/query.rs @@ -8,6 +8,8 @@ use injective_std::types::{cosmos::bank::v1beta1::BankQuerier, injective::exchan pub fn handle_query_stargate_raw(querier: &QuerierWrapper, path: String, query_request: String) -> StdResult { let data = Binary::from_base64(&query_request)?; + + #[allow(deprecated)] let request = &QueryRequest::::Stargate { path, data }; let raw = to_json_vec(request).map_err(|serialize_err| StdError::generic_err(format!("Serializing QueryRequest: {}", serialize_err)))?; diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs index f7278c56..a765f816 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/type_helpers.rs @@ -205,7 +205,6 @@ pub struct QuerySupplyOffResponse { pub amount: Coin, } - #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] pub struct QueryDenomMetadataResponse { pub metadatas: Vec, @@ -233,4 +232,4 @@ pub struct DenomUnit { #[derive(Serialize, Deserialize, Debug)] pub struct Pagination { // Define fields based on your pagination structure, if any -} \ No newline at end of file +} From 41e822aaee64d11154a9557483c1b486a0d24b2b Mon Sep 17 00:00:00 2001 From: maxrobot Date: Mon, 16 Sep 2024 17:10:55 +0100 Subject: [PATCH 16/19] fix: incorrect message --- .../src/testing/authz.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs index 7a994d37..c08df49a 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs @@ -19,7 +19,7 @@ fn test_query_grantee_grants() { execute_all_authorizations(&env.app, &env.users[0].account, env.users[1].account.address().to_string()); execute_all_authorizations(&env.app, &env.users[2].account, env.users[1].account.address().to_string()); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRawRaw { path: "/cosmos.authz.v1beta1.Query/GranteeGrants".to_string(), query_request: encode_proto_message(QueryGranteeGrantsRequest { grantee: env.users[1].account.address().to_string(), @@ -68,7 +68,7 @@ fn test_query_granter_grants() { execute_all_authorizations(&env.app, &env.users[0].account, env.users[1].account.address().to_string()); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/cosmos.authz.v1beta1.Query/GranterGrants".to_string(), query_request: encode_proto_message(QueryGranterGrantsRequest { granter: env.users[0].account.address().to_string(), @@ -79,7 +79,7 @@ fn test_query_granter_grants() { let query_result = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); assert_eq!(query_result.grants.len(), 5); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/cosmos.authz.v1beta1.Query/GranterGrants".to_string(), query_request: encode_proto_message(QueryGranterGrantsRequest { granter: env.users[2].account.address().to_string(), @@ -99,7 +99,7 @@ fn test_query_grants() { execute_all_authorizations(&env.app, &env.users[0].account, env.users[1].account.address().to_string()); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/cosmos.authz.v1beta1.Query/Grants".to_string(), query_request: encode_proto_message(QueryGrantsRequest { granter: env.users[0].account.address().to_string(), @@ -114,7 +114,7 @@ fn test_query_grants() { // let query_result = get_stargate_query_result::(wasm.query(&env.contract_address, &query_msg)).unwrap(); // println!("{:?}", query_result); - let query_msg = QueryMsg::QueryStargate { + let query_msg = QueryMsg::QueryStargateRaw { path: "/cosmos.authz.v1beta1.Query/Grants".to_string(), query_request: encode_proto_message(QueryGrantsRequest { granter: env.users[2].account.address().to_string(), From e43ad9a863890e791740a22c257a294b4b95f037 Mon Sep 17 00:00:00 2001 From: maxrobot Date: Mon, 16 Sep 2024 17:42:15 +0100 Subject: [PATCH 17/19] chore: fix typo --- .../injective-cosmwasm-stargate-example/src/testing/authz.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs b/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs index c08df49a..250932e9 100644 --- a/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs +++ b/contracts/injective-cosmwasm-stargate-example/src/testing/authz.rs @@ -19,7 +19,7 @@ fn test_query_grantee_grants() { execute_all_authorizations(&env.app, &env.users[0].account, env.users[1].account.address().to_string()); execute_all_authorizations(&env.app, &env.users[2].account, env.users[1].account.address().to_string()); - let query_msg = QueryMsg::QueryStargateRawRaw { + let query_msg = QueryMsg::QueryStargateRaw { path: "/cosmos.authz.v1beta1.Query/GranteeGrants".to_string(), query_request: encode_proto_message(QueryGranteeGrantsRequest { grantee: env.users[1].account.address().to_string(), From 2cfe4a1e4d88e0e9fa57280d99cab888417bfca3 Mon Sep 17 00:00:00 2001 From: maxrobot Date: Mon, 16 Sep 2024 19:05:35 +0100 Subject: [PATCH 18/19] fix: cargo conflict --- Cargo.lock | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index e4d866a4..7ed0f98b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2044,9 +2044,9 @@ checksum = "4eae0151b9dacf24fcc170d9995e511669a082856a91f958a2fe380bfab3fb22" [[package]] name = "once_cell" -version = "1.20.0" +version = "1.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe" +checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" [[package]] name = "opaque-debug" From c92a4ad23fa01c8b8a88ec20d6ca69ec317561f1 Mon Sep 17 00:00:00 2001 From: jose Date: Mon, 16 Sep 2024 20:08:38 +0200 Subject: [PATCH 19/19] chore merge dev --- Cargo.lock | 216 +++++++++++++++++++--- contracts/atomic-order-example/Cargo.toml | 2 + packages/injective-math/Cargo.toml | 2 + packages/injective-testing/Cargo.toml | 1 + 4 files changed, 192 insertions(+), 29 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8fc8a4e2..e4d866a4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -17,6 +17,17 @@ version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627" +[[package]] +name = "ahash" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9" +dependencies = [ + "getrandom", + "once_cell", + "version_check", +] + [[package]] name = "ahash" version = "0.8.11" @@ -197,9 +208,11 @@ name = "atomic-order-example" version = "0.2.0" dependencies = [ "cosmwasm-schema 1.5.7", - "cosmwasm-std", + "cosmwasm-std 2.1.3", + "cosmwasm-storage", "cw-multi-test", "cw-storage-plus", + "cw-utils", "cw2", "injective-cosmwasm 0.3.0", "injective-math 0.3.0", @@ -266,6 +279,12 @@ version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b" +[[package]] +name = "bech32" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d86b93f97252c47b41663388e6d155714a9d0c398b99f1005cbc5f978b29f445" + [[package]] name = "bech32" version = "0.11.0" @@ -341,6 +360,12 @@ dependencies = [ "generic-array", ] +[[package]] +name = "bnum" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56953345e39537a3e18bdaeba4cb0c58a78c1f61f361dc0fa7c5c7340ae87c5f" + [[package]] name = "bnum" version = "0.11.0" @@ -514,6 +539,19 @@ version = "2.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d905990ef3afb5753bb709dc7de88e9e370aa32bcc2f31731d4b533b63e82490" +[[package]] +name = "cosmwasm-crypto" +version = "1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f862b355f7e47711e0acfe6af92cb3fd8fd5936b66a9eaa338b51edabd1e77d" +dependencies = [ + "digest 0.10.7", + "ed25519-zebra 3.1.0", + "k256", + "rand_core 0.6.4", + "thiserror", +] + [[package]] name = "cosmwasm-crypto" version = "2.1.3" @@ -527,7 +565,7 @@ dependencies = [ "cosmwasm-core", "digest 0.10.7", "ecdsa", - "ed25519-zebra", + "ed25519-zebra 4.0.3", "k256", "num-traits", "p256", @@ -537,6 +575,15 @@ dependencies = [ "thiserror", ] +[[package]] +name = "cosmwasm-derive" +version = "1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd85de6467cd1073688c86b39833679ae6db18cf4771471edd9809f15f1679f1" +dependencies = [ + "syn 1.0.109", +] + [[package]] name = "cosmwasm-derive" version = "2.1.3" @@ -596,6 +643,28 @@ dependencies = [ "syn 2.0.77", ] +[[package]] +name = "cosmwasm-std" +version = "1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2685c2182624b2e9e17f7596192de49a3f86b7a0c9a5f6b25c1df5e24592e836" +dependencies = [ + "base64 0.21.7", + "bech32 0.9.1", + "bnum 0.10.0", + "cosmwasm-crypto 1.5.7", + "cosmwasm-derive 1.5.7", + "derivative", + "forward_ref", + "hex", + "schemars", + "serde 1.0.210", + "serde-json-wasm 0.5.2", + "sha2 0.10.8", + "static_assertions 1.1.0", + "thiserror", +] + [[package]] name = "cosmwasm-std" version = "2.1.3" @@ -603,22 +672,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "51dec99a2e478715c0a4277f0dbeadbb8466500eb7dec873d0924edd086e77f1" dependencies = [ "base64 0.22.1", - "bech32", - "bnum", + "bech32 0.11.0", + "bnum 0.11.0", "cosmwasm-core", - "cosmwasm-crypto", - "cosmwasm-derive", + "cosmwasm-crypto 2.1.3", + "cosmwasm-derive 2.1.3", "derive_more", "hex", "rand_core 0.6.4", "schemars", "serde 1.0.210", - "serde-json-wasm", + "serde-json-wasm 1.0.1", "sha2 0.10.8", "static_assertions 1.1.0", "thiserror", ] +[[package]] +name = "cosmwasm-storage" +version = "1.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "66de2ab9db04757bcedef2b5984fbe536903ada4a8a9766717a4a71197ef34f6" +dependencies = [ + "cosmwasm-std 1.5.7", + "serde 1.0.210", +] + [[package]] name = "cpufeatures" version = "0.2.14" @@ -681,6 +760,19 @@ dependencies = [ "typenum", ] +[[package]] +name = "curve25519-dalek" +version = "3.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61" +dependencies = [ + "byteorder", + "digest 0.9.0", + "rand_core 0.5.1", + "subtle", + "zeroize", +] + [[package]] name = "curve25519-dalek" version = "4.1.3" @@ -728,8 +820,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b0ae276e7a06ad1b7e7da78a3d68aba80634cde30ee7fe8259a94e653603fef8" dependencies = [ "anyhow", - "bech32", - "cosmwasm-std", + "bech32 0.11.0", + "cosmwasm-std 2.1.3", "cw-storage-plus", "cw-utils", "derivative", @@ -747,7 +839,7 @@ version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f13360e9007f51998d42b1bc6b7fa0141f74feae61ed5fd1e5b0a89eec7b5de1" dependencies = [ - "cosmwasm-std", + "cosmwasm-std 2.1.3", "schemars", "serde 1.0.210", ] @@ -759,7 +851,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "07dfee7f12f802431a856984a32bce1cb7da1e6c006b5409e3981035ce562dec" dependencies = [ "cosmwasm-schema 2.1.3", - "cosmwasm-std", + "cosmwasm-std 2.1.3", "schemars", "serde 1.0.210", "thiserror", @@ -772,7 +864,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b04852cd38f044c0751259d5f78255d07590d136b8a86d4e09efdd7666bd6d27" dependencies = [ "cosmwasm-schema 2.1.3", - "cosmwasm-std", + "cosmwasm-std 2.1.3", "cw-storage-plus", "schemars", "semver", @@ -862,7 +954,7 @@ checksum = "59f8e79d1fbf76bdfbde321e902714bf6c49df88a7dda6fc682fc2979226962d" name = "dummy" version = "1.1.0" dependencies = [ - "cosmwasm-std", + "cosmwasm-std 2.1.3", "cw-storage-plus", "cw2", "injective-cosmwasm 0.3.0", @@ -914,13 +1006,28 @@ dependencies = [ "zeroize", ] +[[package]] +name = "ed25519-zebra" +version = "3.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c24f403d068ad0b359e577a77f92392118be3f3c927538f2bb544a5ecd828c6" +dependencies = [ + "curve25519-dalek 3.2.0", + "hashbrown 0.12.3", + "hex", + "rand_core 0.6.4", + "serde 1.0.210", + "sha2 0.9.9", + "zeroize", +] + [[package]] name = "ed25519-zebra" version = "4.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7d9ce6874da5d4415896cd45ffbc4d1cfc0c4f9c079427bd870742c30f2f65a9" dependencies = [ - "curve25519-dalek", + "curve25519-dalek 4.1.3", "ed25519", "hashbrown 0.14.5", "hex", @@ -1101,6 +1208,12 @@ dependencies = [ "percent-encoding", ] +[[package]] +name = "forward_ref" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8cbd1169bd7b4a0a20d92b9af7a7e0422888bd38a6f5ec29c1fd8c1558a272e" + [[package]] name = "fuchsia-cprng" version = "0.1.1" @@ -1245,6 +1358,9 @@ name = "hashbrown" version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" +dependencies = [ + "ahash 0.7.8", +] [[package]] name = "hashbrown" @@ -1252,7 +1368,7 @@ version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e" dependencies = [ - "ahash", + "ahash 0.8.11", ] [[package]] @@ -1261,7 +1377,7 @@ version = "0.14.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" dependencies = [ - "ahash", + "ahash 0.8.11", "allocator-api2", ] @@ -1453,14 +1569,14 @@ name = "injective-cosmwasm" version = "0.3.0" dependencies = [ "cosmwasm-schema 1.5.7", - "cosmwasm-std", + "cosmwasm-std 2.1.3", "cw-storage-plus", "ethereum-types", "hex", "injective-math 0.3.0", "schemars", "serde 1.0.210", - "serde-json-wasm", + "serde-json-wasm 1.0.1", "serde_repr", "serde_test", "subtle-encoding", @@ -1473,7 +1589,7 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "23e93e9438844b10add3eb40ed1e8c92689824ac080d207f856412a73551c221" dependencies = [ - "cosmwasm-std", + "cosmwasm-std 2.1.3", "cw-storage-plus", "ethereum-types", "hex", @@ -1491,7 +1607,28 @@ version = "1.0.0" dependencies = [ "cosmos-sdk-proto", "cosmwasm-schema 1.5.7", - "cosmwasm-std", + "cosmwasm-std 2.1.3", + "cw-storage-plus", + "cw2", + "injective-cosmwasm 0.3.0", + "injective-math 0.3.0", + "injective-std 1.13.0", + "injective-test-tube", + "injective-testing", + "prost 0.12.6", + "schemars", + "serde 1.0.210", + "thiserror", +] + +[[package]] +name = "injective-cosmwasm-stargate-example" +version = "0.0.1" +dependencies = [ + "base64 0.21.7", + "cosmos-sdk-proto", + "cosmwasm-schema 1.5.7", + "cosmwasm-std 2.1.3", "cw-storage-plus", "cw2", "injective-cosmwasm 0.3.0", @@ -1502,6 +1639,7 @@ dependencies = [ "prost 0.12.6", "schemars", "serde 1.0.210", + "serde_json 1.0.128", "thiserror", ] @@ -1510,10 +1648,12 @@ name = "injective-math" version = "0.3.0" dependencies = [ "cosmwasm-schema 1.5.7", - "cosmwasm-std", + "cosmwasm-std 2.1.3", + "ethereum-types", "primitive-types", "schemars", "serde 1.0.210", + "subtle-encoding", ] [[package]] @@ -1522,7 +1662,7 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "194fb5cb49537b0b9137d02a563b7019003220fb4affff05ad6cdc6fee3509c9" dependencies = [ - "cosmwasm-std", + "cosmwasm-std 2.1.3", "ethereum-types", "primitive-types", "schemars", @@ -1535,7 +1675,7 @@ name = "injective-std" version = "1.13.0" dependencies = [ "chrono", - "cosmwasm-std", + "cosmwasm-std 2.1.3", "injective-std-derive 1.13.0", "prost 0.12.6", "prost-types 0.12.6", @@ -1551,7 +1691,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c0e5193cb9520754f60b9e9af08a662ddf298d2e1a579200b9a447064b64db8b" dependencies = [ "chrono", - "cosmwasm-std", + "cosmwasm-std 2.1.3", "injective-std-derive 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)", "prost 0.12.6", "prost-types 0.12.6", @@ -1564,7 +1704,7 @@ dependencies = [ name = "injective-std-derive" version = "1.13.0" dependencies = [ - "cosmwasm-std", + "cosmwasm-std 2.1.3", "itertools 0.10.5", "proc-macro2", "prost 0.12.6", @@ -1580,7 +1720,7 @@ version = "1.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2721d8c2fed1fd1dff4cd6d119711a74acf27a6eeea6bf09cd44d192119e52ea" dependencies = [ - "cosmwasm-std", + "cosmwasm-std 2.1.3", "itertools 0.10.5", "proc-macro2", "quote", @@ -1596,7 +1736,7 @@ dependencies = [ "base64 0.21.7", "bindgen", "cosmrs", - "cosmwasm-std", + "cosmwasm-std 2.1.3", "hex", "injective-cosmwasm 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", "injective-std 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1612,7 +1752,8 @@ name = "injective-testing" version = "1.1.0" dependencies = [ "anyhow", - "cosmwasm-std", + "base64 0.21.7", + "cosmwasm-std 2.1.3", "cw-multi-test", "injective-cosmwasm 0.3.0", "injective-math 0.3.0", @@ -1682,7 +1823,9 @@ dependencies = [ "cfg-if", "ecdsa", "elliptic-curve", + "once_cell", "sha2 0.10.8", + "signature", ] [[package]] @@ -2233,6 +2376,12 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc" +[[package]] +name = "rand_core" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" + [[package]] name = "rand_core" version = "0.6.4" @@ -2616,6 +2765,15 @@ dependencies = [ "serde 1.0.210", ] +[[package]] +name = "serde-json-wasm" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e9213a07d53faa0b8dd81e767a54a8188a242fdb9be99ab75ec576a774bfdd7" +dependencies = [ + "serde 1.0.210", +] + [[package]] name = "serde-json-wasm" version = "1.0.1" @@ -3013,7 +3171,7 @@ checksum = "3c3a4e34619e6417613fab682de9a196848f4a56653ac71b95b5860b6d87c7cd" dependencies = [ "base64 0.21.7", "cosmrs", - "cosmwasm-std", + "cosmwasm-std 2.1.3", "prost 0.12.6", "serde 1.0.210", "serde_json 1.0.128", diff --git a/contracts/atomic-order-example/Cargo.toml b/contracts/atomic-order-example/Cargo.toml index 1e90cfc8..247bb19a 100644 --- a/contracts/atomic-order-example/Cargo.toml +++ b/contracts/atomic-order-example/Cargo.toml @@ -28,7 +28,9 @@ optimize = """docker run --rm -v "$(pwd)":/code \ [dependencies] cosmwasm-std = { workspace = true } +cosmwasm-storage = { workspace = true } cw-storage-plus = { workspace = true } +cw-utils = { workspace = true } cw2 = { workspace = true } injective-cosmwasm = { path = "../../packages/injective-cosmwasm" } injective-math = { path = "../../packages/injective-math" } diff --git a/packages/injective-math/Cargo.toml b/packages/injective-math/Cargo.toml index 01ba28b7..33f677bc 100644 --- a/packages/injective-math/Cargo.toml +++ b/packages/injective-math/Cargo.toml @@ -14,9 +14,11 @@ version = "0.3.0" [dependencies] cosmwasm-std = { workspace = true } +ethereum-types = { workspace = true } primitive-types = { workspace = true } schemars = { workspace = true } serde = { workspace = true } +subtle-encoding = { workspace = true } [dev-dependencies] cosmwasm-schema = { workspace = true } diff --git a/packages/injective-testing/Cargo.toml b/packages/injective-testing/Cargo.toml index b46ea20d..45fb841a 100644 --- a/packages/injective-testing/Cargo.toml +++ b/packages/injective-testing/Cargo.toml @@ -9,6 +9,7 @@ version = "1.1.0" [dependencies] anyhow = { workspace = true } +base64 = { workspace = true } cosmwasm-std = { workspace = true } cw-multi-test = { workspace = true } injective-cosmwasm = { path = "../injective-cosmwasm" }