From 26f1cc1cd5f794d3eebb767bbaeb7f07f7f7114d Mon Sep 17 00:00:00 2001 From: Aleksandr Pismenskiy Date: Tue, 2 Apr 2024 01:24:32 +0300 Subject: [PATCH 1/4] feat: added title field #NTRN-174 --- .../cwd-proposal-multiple/src/proposal.rs | 2 ++ .../src/testing/do_votes.rs | 2 ++ .../src/testing/tests.rs | 36 ++++++++++++++++++- packages/cwd-voting/src/multiple_choice.rs | 7 ++++ 4 files changed, 46 insertions(+), 1 deletion(-) diff --git a/contracts/dao/proposal/cwd-proposal-multiple/src/proposal.rs b/contracts/dao/proposal/cwd-proposal-multiple/src/proposal.rs index e1e48fef..60c3a54d 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/src/proposal.rs +++ b/contracts/dao/proposal/cwd-proposal-multiple/src/proposal.rs @@ -284,10 +284,12 @@ mod tests { // The last option that gets added in into_checked is always the none of the above option let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, diff --git a/contracts/dao/proposal/cwd-proposal-multiple/src/testing/do_votes.rs b/contracts/dao/proposal/cwd-proposal-multiple/src/testing/do_votes.rs index d9e34160..8e1a956a 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/src/testing/do_votes.rs +++ b/contracts/dao/proposal/cwd-proposal-multiple/src/testing/do_votes.rs @@ -156,10 +156,12 @@ where let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, diff --git a/contracts/dao/proposal/cwd-proposal-multiple/src/testing/tests.rs b/contracts/dao/proposal/cwd-proposal-multiple/src/testing/tests.rs index d331f91c..2ffacb45 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/src/testing/tests.rs +++ b/contracts/dao/proposal/cwd-proposal-multiple/src/testing/tests.rs @@ -149,11 +149,13 @@ fn test_propose() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { - description: "multiple choice option 1".to_string(), + title: "title".to_string(), + description: "multiple choice option 2".to_string(), msgs: None, }, ]; @@ -243,6 +245,7 @@ fn test_propose_wrong_num_choices() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }; @@ -343,10 +346,12 @@ fn test_no_early_pass_with_min_duration() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -452,10 +457,12 @@ fn test_propose_with_messages() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: Some(vec![CosmosMsg::Wasm(wasm_msg)]), }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -613,10 +620,12 @@ fn test_min_duration_same_as_proposal_duration() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -786,10 +795,12 @@ fn test_native_proposal_deposit() { let mc_options = MultipleChoiceOptions { options: vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -919,10 +930,12 @@ fn test_cant_propose_zero_power() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -1016,10 +1029,12 @@ fn test_open_proposal_submission() { MultipleChoiceOptions { options: vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -1044,6 +1059,7 @@ fn test_open_proposal_submission() { }, choices: vec![ CheckedMultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, option_type: MultipleChoiceOptionType::Standard, @@ -1051,6 +1067,7 @@ fn test_open_proposal_submission() { index: 0, }, CheckedMultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, option_type: MultipleChoiceOptionType::Standard, @@ -1058,6 +1075,7 @@ fn test_open_proposal_submission() { index: 1, }, CheckedMultipleChoiceOption { + title: "None of the above".to_string(), description: "None of the above".to_string(), msgs: None, option_type: MultipleChoiceOptionType::None, @@ -1117,10 +1135,12 @@ fn test_execute_expired_proposal() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -1236,10 +1256,12 @@ fn test_query_list_proposals() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -1485,10 +1507,12 @@ fn test_revoting() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -1612,10 +1636,12 @@ fn test_allow_revoting_config_changes() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -1757,10 +1783,12 @@ fn test_revoting_same_vote_twice() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -1847,10 +1875,12 @@ fn test_invalid_revote_does_not_invalidate_initial_vote() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -1967,6 +1997,7 @@ fn test_close_failed_proposal() { let options = vec![ MultipleChoiceOption { + title: "title".to_string(), description: "Burn or burn".to_string(), msgs: Some(vec![WasmMsg::Execute { contract_addr: "token_contract".to_string(), @@ -1976,6 +2007,7 @@ fn test_close_failed_proposal() { .into()]), }, MultipleChoiceOption { + title: "title".to_string(), description: "Don't burn".to_string(), msgs: None, }, @@ -2039,6 +2071,7 @@ fn test_close_failed_proposal() { choices: MultipleChoiceOptions { options: vec![ MultipleChoiceOption { + title: "title".to_string(), description: "Disable closing failed proposals".to_string(), msgs: Some(vec![WasmMsg::Execute { contract_addr: govmod.to_string(), @@ -2057,6 +2090,7 @@ fn test_close_failed_proposal() { .into()]), }, MultipleChoiceOption { + title: "title".to_string(), description: "Don't disable".to_string(), msgs: None, }, diff --git a/packages/cwd-voting/src/multiple_choice.rs b/packages/cwd-voting/src/multiple_choice.rs index b269bd4f..a1264c2b 100644 --- a/packages/cwd-voting/src/multiple_choice.rs +++ b/packages/cwd-voting/src/multiple_choice.rs @@ -100,6 +100,7 @@ pub struct MultipleChoiceOptions { /// Unchecked multiple choice option #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)] pub struct MultipleChoiceOption { + pub title: String, pub description: String, pub msgs: Option>>, } @@ -118,6 +119,7 @@ pub struct CheckedMultipleChoiceOption { // Workaround due to not being able to use HashMaps in Cosmwasm. pub index: u32, pub option_type: MultipleChoiceOptionType, + pub title: String, pub description: String, pub msgs: Option>>, pub vote_count: Uint128, @@ -142,6 +144,7 @@ impl MultipleChoiceOptions { let checked_option = CheckedMultipleChoiceOption { index: idx as u32, option_type: MultipleChoiceOptionType::Standard, + title: choice.title, description: choice.description, msgs: choice.msgs, vote_count: Uint128::zero(), @@ -153,6 +156,7 @@ impl MultipleChoiceOptions { let none_option = CheckedMultipleChoiceOption { index: (checked_options.capacity() - 1) as u32, option_type: MultipleChoiceOptionType::None, + title: NONE_OPTION_DESCRIPTION.to_string(), description: NONE_OPTION_DESCRIPTION.to_string(), msgs: None, vote_count: Uint128::zero(), @@ -205,10 +209,12 @@ mod test { fn test_into_checked() { let options = vec![ super::MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }, super::MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 2".to_string(), msgs: None, }, @@ -248,6 +254,7 @@ mod test { #[test] fn test_into_checked_wrong_num_choices() { let options = vec![super::MultipleChoiceOption { + title: "title".to_string(), description: "multiple choice option 1".to_string(), msgs: None, }]; From 9def9786989f88e0697aa273215ef4aa64f58a02 Mon Sep 17 00:00:00 2001 From: Aleksandr Pismenskiy Date: Mon, 8 Apr 2024 01:40:14 +0300 Subject: [PATCH 2/4] implemented migrate handler, added unit test --- Cargo.lock | 1 + .../cwd-proposal-multiple/src/contract.rs | 53 +++++++- .../cwd-proposal-multiple/src/proposal.rs | 19 ++- .../cwd-proposal-multiple/src/state.rs | 4 +- .../src/testing/tests.rs | 120 +++++++++++++++++- packages/cwd-voting/Cargo.toml | 1 + packages/cwd-voting/src/multiple_choice.rs | 10 ++ 7 files changed, 198 insertions(+), 10 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 5a31c816..727b896b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1279,6 +1279,7 @@ dependencies = [ name = "cwd-voting" version = "0.2.0" dependencies = [ + "cosmwasm-schema", "cosmwasm-std", "cw-denom", "cw-storage-plus 1.2.0", diff --git a/contracts/dao/proposal/cwd-proposal-multiple/src/contract.rs b/contracts/dao/proposal/cwd-proposal-multiple/src/contract.rs index d4aa3b4e..42b85d82 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/src/contract.rs +++ b/contracts/dao/proposal/cwd-proposal-multiple/src/contract.rs @@ -15,7 +15,8 @@ use cwd_proposal_hooks::{new_proposal_hooks, proposal_status_changed_hooks}; use cwd_vote_hooks::new_vote_hooks; use cwd_voting::{ multiple_choice::{ - MultipleChoiceOptions, MultipleChoiceVote, MultipleChoiceVotes, VotingStrategy, + CheckedMultipleChoiceOption, MultipleChoiceOptions, MultipleChoiceVote, + MultipleChoiceVotes, VotingStrategy, }, pre_propose::{PreProposeInfo, ProposalCreationPolicy}, proposal::{DEFAULT_LIMIT, MAX_PROPOSAL_SIZE}, @@ -30,10 +31,11 @@ use crate::state::PROPOSAL_EXECUTION_ERRORS; use crate::{msg::MigrateMsg, state::CREATION_POLICY}; use crate::{ msg::{ExecuteMsg, InstantiateMsg, QueryMsg}, - proposal::{MultipleChoiceProposal, VoteResult}, + proposal::{MultipleChoiceProposal, OldMultipleChoiceProposal, VoteResult}, query::{ProposalListResponse, ProposalResponse, VoteInfo, VoteListResponse, VoteResponse}, state::{ - Ballot, Config, BALLOTS, CONFIG, PROPOSALS, PROPOSAL_COUNT, PROPOSAL_HOOKS, VOTE_HOOKS, + Ballot, Config, BALLOTS, CONFIG, OLD_PROPOSALS, PROPOSALS, PROPOSAL_COUNT, PROPOSAL_HOOKS, + VOTE_HOOKS, }, ContractError, }; @@ -918,5 +920,48 @@ pub fn reply(deps: DepsMut, _env: Env, msg: Reply) -> Result Result { set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?; - Ok(Response::default()) + + let mut migrated_proposal_ids: Vec = vec![]; + + OLD_PROPOSALS + .range(deps.storage, None, None, cosmwasm_std::Order::Ascending) + .collect::>>()? + .into_iter() + .try_for_each(|(id, prop)| { + migrated_proposal_ids.push(id.to_string()); + + PROPOSALS.save( + deps.storage, + id, + &MultipleChoiceProposal { + title: prop.title, + description: prop.description, + proposer: prop.proposer, + start_height: prop.start_height, + min_voting_period: prop.min_voting_period, + expiration: prop.expiration, + choices: prop + .choices + .into_iter() + .map(|choice| CheckedMultipleChoiceOption { + index: choice.index, + option_type: choice.option_type, + title: "".to_string(), + description: choice.description, + msgs: choice.msgs, + vote_count: choice.vote_count, + }) + .collect(), + status: prop.status, + voting_strategy: prop.voting_strategy, + total_power: prop.total_power, + votes: prop.votes, + allow_revoting: prop.allow_revoting, + }, + ) + })?; + + Ok(Response::default() + .add_attribute("action", "migrate") + .add_attribute("migrated_proposal_ids", migrated_proposal_ids.join(","))) } diff --git a/contracts/dao/proposal/cwd-proposal-multiple/src/proposal.rs b/contracts/dao/proposal/cwd-proposal-multiple/src/proposal.rs index 60c3a54d..405333ee 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/src/proposal.rs +++ b/contracts/dao/proposal/cwd-proposal-multiple/src/proposal.rs @@ -3,7 +3,8 @@ use cosmwasm_std::{Addr, BlockInfo, StdError, StdResult, Uint128}; use cw_utils::Expiration; use cwd_voting::{ multiple_choice::{ - CheckedMultipleChoiceOption, MultipleChoiceOptionType, MultipleChoiceVotes, VotingStrategy, + CheckedMultipleChoiceOption, MultipleChoiceOptionType, MultipleChoiceVotes, + OldCheckedMultipleChoiceOption, VotingStrategy, }, proposal::Proposal, status::Status, @@ -46,6 +47,22 @@ pub struct MultipleChoiceProposal { pub allow_revoting: bool, } +#[cw_serde] +pub struct OldMultipleChoiceProposal { + pub title: String, + pub description: String, + pub proposer: Addr, + pub start_height: u64, + pub min_voting_period: Option, + pub expiration: Expiration, + pub choices: Vec, + pub status: Status, + pub voting_strategy: VotingStrategy, + pub total_power: Uint128, + pub votes: MultipleChoiceVotes, + pub allow_revoting: bool, +} + pub enum VoteResult { SingleWinner(CheckedMultipleChoiceOption), Tie, diff --git a/contracts/dao/proposal/cwd-proposal-multiple/src/state.rs b/contracts/dao/proposal/cwd-proposal-multiple/src/state.rs index 96272b9d..4ddfbcd0 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/src/state.rs +++ b/contracts/dao/proposal/cwd-proposal-multiple/src/state.rs @@ -1,4 +1,4 @@ -use crate::proposal::MultipleChoiceProposal; +use crate::proposal::{MultipleChoiceProposal, OldMultipleChoiceProposal}; use cosmwasm_schema::cw_serde; use cosmwasm_std::{Addr, Uint128}; use cw_storage_plus::{Item, Map}; @@ -55,6 +55,8 @@ pub struct Ballot { pub vote: MultipleChoiceVote, } +pub const OLD_PROPOSALS: Map = Map::new("proposals"); + /// The current top level config for the module. pub const CONFIG: Item = Item::new("config"); pub const PROPOSAL_COUNT: Item = Item::new("proposal_count"); diff --git a/contracts/dao/proposal/cwd-proposal-multiple/src/testing/tests.rs b/contracts/dao/proposal/cwd-proposal-multiple/src/testing/tests.rs index 2ffacb45..c04e3173 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/src/testing/tests.rs +++ b/contracts/dao/proposal/cwd-proposal-multiple/src/testing/tests.rs @@ -17,8 +17,8 @@ use cwd_voting::{ deposit::{CheckedDepositInfo, DepositRefundPolicy, DepositToken, UncheckedDepositInfo}, multiple_choice::{ CheckedMultipleChoiceOption, MultipleChoiceOption, MultipleChoiceOptionType, - MultipleChoiceOptions, MultipleChoiceVote, MultipleChoiceVotes, VotingStrategy, - MAX_NUM_CHOICES, + MultipleChoiceOptions, MultipleChoiceVote, MultipleChoiceVotes, + OldCheckedMultipleChoiceOption, VotingStrategy, MAX_NUM_CHOICES, }, pre_propose::PreProposeInfo, status::Status, @@ -28,8 +28,8 @@ use neutron_sdk::bindings::msg::NeutronMsg; use std::panic; use crate::{ - msg::{ExecuteMsg, InstantiateMsg, QueryMsg}, - proposal::MultipleChoiceProposal, + msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg}, + proposal::{MultipleChoiceProposal, OldMultipleChoiceProposal}, query::{ProposalListResponse, ProposalResponse}, state::Config, testing::{ @@ -2222,3 +2222,115 @@ fn test_reply_proposal_mock() { let error: Option = from_json(query_res).unwrap(); assert_eq!(error, Some("error".to_string())); } + +#[test] +fn test_migrate_mock() { + use crate::contract::migrate; + use crate::state::{OLD_PROPOSALS, PROPOSALS}; + + let mut deps = mock_dependencies(); + let env = mock_env(); + let max_voting_period = cw_utils::Duration::Height(6); + + OLD_PROPOSALS + .save( + deps.as_mut().storage, + 0, + &OldMultipleChoiceProposal { + title: "A simple text proposal".to_string(), + description: "This is a simple text proposal".to_string(), + proposer: Addr::unchecked(CREATOR_ADDR), + start_height: env.block.height, + min_voting_period: None, + expiration: max_voting_period.after(&env.block), + choices: vec![ + OldCheckedMultipleChoiceOption { + description: "multiple choice option 1".to_string(), + msgs: None, + option_type: MultipleChoiceOptionType::Standard, + vote_count: Uint128::zero(), + index: 0, + }, + OldCheckedMultipleChoiceOption { + description: "multiple choice option 2".to_string(), + msgs: None, + option_type: MultipleChoiceOptionType::Standard, + vote_count: Uint128::zero(), + index: 1, + }, + OldCheckedMultipleChoiceOption { + description: "None of the above".to_string(), + msgs: None, + option_type: MultipleChoiceOptionType::None, + vote_count: Uint128::zero(), + index: 2, + }, + ], + status: Status::Open, + voting_strategy: VotingStrategy::SingleChoice { + quorum: cwd_voting::threshold::PercentageThreshold::Majority {}, + }, + total_power: Uint128::new(100), + votes: MultipleChoiceVotes { + vote_weights: vec![Uint128::zero(); 3], + }, + allow_revoting: false, + }, + ) + .unwrap(); + + let msg = MigrateMsg::FromV1 { + close_proposal_on_execution_failure: true, + pre_propose_info: PreProposeInfo::AnyoneMayPropose {}, + }; + + migrate(deps.as_mut(), env.clone(), msg.clone()).unwrap(); + + let migrated_proposal = PROPOSALS.load(deps.as_mut().storage, 0).unwrap(); + + let expected = MultipleChoiceProposal { + title: "A simple text proposal".to_string(), + description: "This is a simple text proposal".to_string(), + proposer: Addr::unchecked(CREATOR_ADDR), + start_height: env.block.height, + min_voting_period: None, + expiration: max_voting_period.after(&env.block), + choices: vec![ + CheckedMultipleChoiceOption { + title: "".to_string(), + description: "multiple choice option 1".to_string(), + msgs: None, + option_type: MultipleChoiceOptionType::Standard, + vote_count: Uint128::zero(), + index: 0, + }, + CheckedMultipleChoiceOption { + title: "".to_string(), + description: "multiple choice option 2".to_string(), + msgs: None, + option_type: MultipleChoiceOptionType::Standard, + vote_count: Uint128::zero(), + index: 1, + }, + CheckedMultipleChoiceOption { + title: "".to_string(), + description: "None of the above".to_string(), + msgs: None, + option_type: MultipleChoiceOptionType::None, + vote_count: Uint128::zero(), + index: 2, + }, + ], + status: Status::Open, + voting_strategy: VotingStrategy::SingleChoice { + quorum: cwd_voting::threshold::PercentageThreshold::Majority {}, + }, + total_power: Uint128::new(100), + votes: MultipleChoiceVotes { + vote_weights: vec![Uint128::zero(); 3], + }, + allow_revoting: false, + }; + + assert_eq!(migrated_proposal, expected); +} diff --git a/packages/cwd-voting/Cargo.toml b/packages/cwd-voting/Cargo.toml index 68e47f50..80119fec 100644 --- a/packages/cwd-voting/Cargo.toml +++ b/packages/cwd-voting/Cargo.toml @@ -8,6 +8,7 @@ description = "Types and methods for CosmWasm DAO voting." [dependencies] neutron-sdk = "0.10.0" +cosmwasm-schema = { version = "1.3.0" } cosmwasm-std = { version = "1.3.0" } schemars = "0.8.8" serde = { version = "1.0.175", default-features = false, features = ["derive"] } diff --git a/packages/cwd-voting/src/multiple_choice.rs b/packages/cwd-voting/src/multiple_choice.rs index a1264c2b..a3e9b47f 100644 --- a/packages/cwd-voting/src/multiple_choice.rs +++ b/packages/cwd-voting/src/multiple_choice.rs @@ -1,3 +1,4 @@ +use cosmwasm_schema::cw_serde; use cosmwasm_std::{CosmosMsg, StdError, StdResult, Uint128}; use neutron_sdk::bindings::msg::NeutronMsg; use schemars::JsonSchema; @@ -125,6 +126,15 @@ pub struct CheckedMultipleChoiceOption { pub vote_count: Uint128, } +#[cw_serde] +pub struct OldCheckedMultipleChoiceOption { + pub index: u32, + pub option_type: MultipleChoiceOptionType, + pub description: String, + pub msgs: Option>>, + pub vote_count: Uint128, +} + impl MultipleChoiceOptions { pub fn into_checked(self) -> StdResult { if self.options.len() < 2 || self.options.len() > MAX_NUM_CHOICES as usize { From c669839ed4ba75c2e8adb593e76d743125ee70ed Mon Sep 17 00:00:00 2001 From: Aleksandr Pismenskiy Date: Mon, 8 Apr 2024 14:46:05 +0300 Subject: [PATCH 3/4] moved OLD_PROPOSALS out of the state, added comments --- .../dao/proposal/cwd-proposal-multiple/src/contract.rs | 7 ++++--- .../dao/proposal/cwd-proposal-multiple/src/proposal.rs | 2 ++ contracts/dao/proposal/cwd-proposal-multiple/src/state.rs | 4 +--- .../proposal/cwd-proposal-multiple/src/testing/tests.rs | 6 ++++-- packages/cwd-voting/src/multiple_choice.rs | 2 ++ 5 files changed, 13 insertions(+), 8 deletions(-) diff --git a/contracts/dao/proposal/cwd-proposal-multiple/src/contract.rs b/contracts/dao/proposal/cwd-proposal-multiple/src/contract.rs index 42b85d82..80b10a58 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/src/contract.rs +++ b/contracts/dao/proposal/cwd-proposal-multiple/src/contract.rs @@ -6,7 +6,7 @@ use cosmwasm_std::{ }; use cw2::set_contract_version; -use cw_storage_plus::Bound; +use cw_storage_plus::{Bound, Map}; use cw_utils::{parse_reply_instantiate_data, Duration}; use cwd_hooks::Hooks; use cwd_interface::voting::IsActiveResponse; @@ -34,8 +34,7 @@ use crate::{ proposal::{MultipleChoiceProposal, OldMultipleChoiceProposal, VoteResult}, query::{ProposalListResponse, ProposalResponse, VoteInfo, VoteListResponse, VoteResponse}, state::{ - Ballot, Config, BALLOTS, CONFIG, OLD_PROPOSALS, PROPOSALS, PROPOSAL_COUNT, PROPOSAL_HOOKS, - VOTE_HOOKS, + Ballot, Config, BALLOTS, CONFIG, PROPOSALS, PROPOSAL_COUNT, PROPOSAL_HOOKS, VOTE_HOOKS, }, ContractError, }; @@ -923,6 +922,8 @@ pub fn migrate(deps: DepsMut, _env: Env, _msg: MigrateMsg) -> Result = vec![]; + // This constant is needed to access the old proposals without "title" field inside "choices". + const OLD_PROPOSALS: Map = Map::new("proposals"); OLD_PROPOSALS .range(deps.storage, None, None, cosmwasm_std::Order::Ascending) .collect::>>()? diff --git a/contracts/dao/proposal/cwd-proposal-multiple/src/proposal.rs b/contracts/dao/proposal/cwd-proposal-multiple/src/proposal.rs index 405333ee..17a519ea 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/src/proposal.rs +++ b/contracts/dao/proposal/cwd-proposal-multiple/src/proposal.rs @@ -47,6 +47,8 @@ pub struct MultipleChoiceProposal { pub allow_revoting: bool, } +/// Deprecated. +/// This is the old proposal version without "title" field inside "choices". #[cw_serde] pub struct OldMultipleChoiceProposal { pub title: String, diff --git a/contracts/dao/proposal/cwd-proposal-multiple/src/state.rs b/contracts/dao/proposal/cwd-proposal-multiple/src/state.rs index 4ddfbcd0..96272b9d 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/src/state.rs +++ b/contracts/dao/proposal/cwd-proposal-multiple/src/state.rs @@ -1,4 +1,4 @@ -use crate::proposal::{MultipleChoiceProposal, OldMultipleChoiceProposal}; +use crate::proposal::MultipleChoiceProposal; use cosmwasm_schema::cw_serde; use cosmwasm_std::{Addr, Uint128}; use cw_storage_plus::{Item, Map}; @@ -55,8 +55,6 @@ pub struct Ballot { pub vote: MultipleChoiceVote, } -pub const OLD_PROPOSALS: Map = Map::new("proposals"); - /// The current top level config for the module. pub const CONFIG: Item = Item::new("config"); pub const PROPOSAL_COUNT: Item = Item::new("proposal_count"); diff --git a/contracts/dao/proposal/cwd-proposal-multiple/src/testing/tests.rs b/contracts/dao/proposal/cwd-proposal-multiple/src/testing/tests.rs index c04e3173..060e56be 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/src/testing/tests.rs +++ b/contracts/dao/proposal/cwd-proposal-multiple/src/testing/tests.rs @@ -2226,13 +2226,15 @@ fn test_reply_proposal_mock() { #[test] fn test_migrate_mock() { use crate::contract::migrate; - use crate::state::{OLD_PROPOSALS, PROPOSALS}; + use crate::state::PROPOSALS; + use cw_storage_plus::Map; let mut deps = mock_dependencies(); let env = mock_env(); let max_voting_period = cw_utils::Duration::Height(6); - OLD_PROPOSALS + let old_proposals: Map = Map::new("proposals"); + old_proposals .save( deps.as_mut().storage, 0, diff --git a/packages/cwd-voting/src/multiple_choice.rs b/packages/cwd-voting/src/multiple_choice.rs index a3e9b47f..d400a2b6 100644 --- a/packages/cwd-voting/src/multiple_choice.rs +++ b/packages/cwd-voting/src/multiple_choice.rs @@ -126,6 +126,8 @@ pub struct CheckedMultipleChoiceOption { pub vote_count: Uint128, } +/// Deprecated. +/// This is the old choice option version without "title" field. #[cw_serde] pub struct OldCheckedMultipleChoiceOption { pub index: u32, From c1a85b73b7cda6ef3ae6f7df9cbc8fcfc7d54b65 Mon Sep 17 00:00:00 2001 From: Aleksandr Pismenskiy Date: Thu, 11 Apr 2024 17:25:52 +0300 Subject: [PATCH 4/4] regenerated the schema --- contracts/dao/cwd-core/schema/cwd-core.json | 519 +++- .../dao/cwd-core/schema/raw/execute.json | 517 ++++ .../schema/cwd-pre-propose-multiple.json | 525 +++- .../schema/raw/execute.json | 523 +++- .../schema/cwd-pre-propose-overrule.json | 2 +- .../schema/cwd-pre-propose-single.json | 519 +++- .../schema/raw/execute.json | 517 ++++ .../schema/cwd-proposal-multiple.json | 2212 ++++++++++++++++- .../schema/raw/execute.json | 523 +++- .../raw/response_to_list_proposals.json | 521 ++++ .../schema/raw/response_to_proposal.json | 521 ++++ .../raw/response_to_reverse_proposals.json | 521 ++++ .../schema/cwd-proposal-single.json | 2206 +++++++++++++++- .../schema/raw/execute.json | 517 ++++ .../raw/response_to_list_proposals.json | 517 ++++ .../schema/raw/response_to_proposal.json | 517 ++++ .../raw/response_to_reverse_proposals.json | 517 ++++ .../credits-vault/schema/credits-vault.json | 2 +- .../schema/investors-vesting-vault.json | 2 +- .../lockdrop-vault/schema/lockdrop-vault.json | 2 +- .../neutron-vault/schema/neutron-vault.json | 2 +- .../schema/neutron-voting-registry.json | 2 +- .../schema/vesting-lp-vault.json | 2 +- .../schema/cwd-subdao-core.json | 519 +++- .../cwd-subdao-core/schema/raw/execute.json | 517 ++++ .../schema/cwd-subdao-timelock-single.json | 1647 +++++++++++- .../schema/raw/execute.json | 517 ++++ .../raw/response_to_list_proposals.json | 517 ++++ .../schema/raw/response_to_proposal.json | 517 ++++ .../cwd-security-subdao-pre-propose.json | 519 +++- .../schema/raw/execute.json | 517 ++++ .../schema/cwd-subdao-pre-propose-single.json | 519 +++- .../schema/raw/execute.json | 517 ++++ .../schema/cwd-subdao-proposal-single.json | 2206 +++++++++++++++- .../schema/raw/execute.json | 517 ++++ .../raw/response_to_list_proposals.json | 517 ++++ .../schema/raw/response_to_proposal.json | 517 ++++ .../raw/response_to_reverse_proposals.json | 517 ++++ .../schema/neutron-distribution.json | 2 +- .../reserve/schema/neutron-reserve.json | 2 +- 40 files changed, 22022 insertions(+), 268 deletions(-) diff --git a/contracts/dao/cwd-core/schema/cwd-core.json b/contracts/dao/cwd-core/schema/cwd-core.json index 22cf49e8..8c5c90b7 100644 --- a/contracts/dao/cwd-core/schema/cwd-core.json +++ b/contracts/dao/cwd-core/schema/cwd-core.json @@ -1,6 +1,6 @@ { "contract_name": "cwd-core", - "contract_version": "0.2.1", + "contract_version": "0.2.2", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", @@ -814,6 +814,353 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "Duration": { "description": "Duration is a delta of time. You can add it to a BlockInfo or Expiration to move that further in the future. Note that an height-based Duration and a time-based Expiration cannot be combined", "oneOf": [ @@ -1092,6 +1439,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "ModuleInstantiateInfo": { "description": "Information needed to instantiate a module.", "type": "object", @@ -1150,6 +1536,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1573,6 +1973,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1653,6 +2146,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1758,6 +2264,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/cwd-core/schema/raw/execute.json b/contracts/dao/cwd-core/schema/raw/execute.json index a5d9c145..09c162d1 100644 --- a/contracts/dao/cwd-core/schema/raw/execute.json +++ b/contracts/dao/cwd-core/schema/raw/execute.json @@ -654,6 +654,353 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "Duration": { "description": "Duration is a delta of time. You can add it to a BlockInfo or Expiration to move that further in the future. Note that an height-based Duration and a time-based Expiration cannot be combined", "oneOf": [ @@ -932,6 +1279,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "ModuleInstantiateInfo": { "description": "Information needed to instantiate a module.", "type": "object", @@ -990,6 +1376,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1413,6 +1813,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1493,6 +1986,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1598,6 +2104,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/pre-propose/cwd-pre-propose-multiple/schema/cwd-pre-propose-multiple.json b/contracts/dao/pre-propose/cwd-pre-propose-multiple/schema/cwd-pre-propose-multiple.json index c32b0602..bf2953bb 100644 --- a/contracts/dao/pre-propose/cwd-pre-propose-multiple/schema/cwd-pre-propose-multiple.json +++ b/contracts/dao/pre-propose/cwd-pre-propose-multiple/schema/cwd-pre-propose-multiple.json @@ -1,6 +1,6 @@ { "contract_name": "cwd-pre-propose-multiple", - "contract_version": "0.2.1", + "contract_version": "0.2.2", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", @@ -716,6 +716,42 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, "DepositRefundPolicy": { "oneOf": [ { @@ -780,6 +816,317 @@ } ] }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -1073,6 +1420,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -1091,11 +1477,26 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "MultipleChoiceOption": { "description": "Unchecked multiple choice option", "type": "object", "required": [ - "description" + "description", + "title" ], "properties": { "description": { @@ -1109,6 +1510,9 @@ "items": { "$ref": "#/definitions/CosmosMsg_for_NeutronMsg" } + }, + "title": { + "type": "string" } } }, @@ -1550,6 +1954,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1630,6 +2127,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1735,6 +2245,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/pre-propose/cwd-pre-propose-multiple/schema/raw/execute.json b/contracts/dao/pre-propose/cwd-pre-propose-multiple/schema/raw/execute.json index f532499d..336e0aa7 100644 --- a/contracts/dao/pre-propose/cwd-pre-propose-multiple/schema/raw/execute.json +++ b/contracts/dao/pre-propose/cwd-pre-propose-multiple/schema/raw/execute.json @@ -551,6 +551,42 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, "DepositRefundPolicy": { "oneOf": [ { @@ -615,6 +651,317 @@ } ] }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -908,6 +1255,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -926,11 +1312,26 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "MultipleChoiceOption": { "description": "Unchecked multiple choice option", "type": "object", "required": [ - "description" + "description", + "title" ], "properties": { "description": { @@ -944,6 +1345,9 @@ "items": { "$ref": "#/definitions/CosmosMsg_for_NeutronMsg" } + }, + "title": { + "type": "string" } } }, @@ -1385,6 +1789,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1465,6 +1962,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1570,6 +2080,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/pre-propose/cwd-pre-propose-single-overrule/schema/cwd-pre-propose-overrule.json b/contracts/dao/pre-propose/cwd-pre-propose-single-overrule/schema/cwd-pre-propose-overrule.json index dabbf6ad..de92a5ef 100644 --- a/contracts/dao/pre-propose/cwd-pre-propose-single-overrule/schema/cwd-pre-propose-overrule.json +++ b/contracts/dao/pre-propose/cwd-pre-propose-single-overrule/schema/cwd-pre-propose-overrule.json @@ -1,6 +1,6 @@ { "contract_name": "cwd-pre-propose-overrule", - "contract_version": "0.2.1", + "contract_version": "0.2.2", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", diff --git a/contracts/dao/pre-propose/cwd-pre-propose-single/schema/cwd-pre-propose-single.json b/contracts/dao/pre-propose/cwd-pre-propose-single/schema/cwd-pre-propose-single.json index bceb9a7b..0be1c610 100644 --- a/contracts/dao/pre-propose/cwd-pre-propose-single/schema/cwd-pre-propose-single.json +++ b/contracts/dao/pre-propose/cwd-pre-propose-single/schema/cwd-pre-propose-single.json @@ -1,6 +1,6 @@ { "contract_name": "cwd-pre-propose-single", - "contract_version": "0.2.1", + "contract_version": "0.2.2", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", @@ -716,6 +716,42 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, "DepositRefundPolicy": { "oneOf": [ { @@ -780,6 +816,317 @@ } ] }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -1073,6 +1420,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -1091,6 +1477,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1514,6 +1914,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1594,6 +2087,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1699,6 +2205,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/pre-propose/cwd-pre-propose-single/schema/raw/execute.json b/contracts/dao/pre-propose/cwd-pre-propose-single/schema/raw/execute.json index 6c2a2a20..7add61b1 100644 --- a/contracts/dao/pre-propose/cwd-pre-propose-single/schema/raw/execute.json +++ b/contracts/dao/pre-propose/cwd-pre-propose-single/schema/raw/execute.json @@ -551,6 +551,42 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, "DepositRefundPolicy": { "oneOf": [ { @@ -615,6 +651,317 @@ } ] }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -908,6 +1255,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -926,6 +1312,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1349,6 +1749,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1429,6 +1922,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1534,6 +2040,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/proposal/cwd-proposal-multiple/schema/cwd-proposal-multiple.json b/contracts/dao/proposal/cwd-proposal-multiple/schema/cwd-proposal-multiple.json index 935fdb16..32b4e854 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/schema/cwd-proposal-multiple.json +++ b/contracts/dao/proposal/cwd-proposal-multiple/schema/cwd-proposal-multiple.json @@ -1,6 +1,6 @@ { "contract_name": "cwd-proposal-multiple", - "contract_version": "0.2.1", + "contract_version": "0.2.2", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", @@ -1047,6 +1047,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -1374,6 +1721,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "ModuleInstantiateInfo": { "description": "Information needed to instantiate a module.", "type": "object", @@ -1432,11 +1818,26 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "MultipleChoiceOption": { "description": "Unchecked multiple choice option", "type": "object", "required": [ - "description" + "description", + "title" ], "properties": { "description": { @@ -1450,6 +1851,9 @@ "items": { "$ref": "#/definitions/CosmosMsg_for_NeutronMsg" } + }, + "title": { + "type": "string" } } }, @@ -1905,6 +2309,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1985,6 +2482,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -2159,6 +2669,17 @@ } ] }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", @@ -3680,6 +4201,7 @@ "description", "index", "option_type", + "title", "vote_count" ], "properties": { @@ -3703,6 +4225,9 @@ "option_type": { "$ref": "#/definitions/MultipleChoiceOptionType" }, + "title": { + "type": "string" + }, "vote_count": { "$ref": "#/definitions/Uint128" } @@ -3804,46 +4329,336 @@ { "type": "object", "required": [ - "staking" + "staking" + ], + "properties": { + "staking": { + "$ref": "#/definitions/StakingMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "distribution" + ], + "properties": { + "distribution": { + "$ref": "#/definitions/DistributionMsg" + } + }, + "additionalProperties": false + }, + { + "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "type": "object", + "required": [ + "stargate" + ], + "properties": { + "stargate": { + "type": "object", + "required": [ + "type_url", + "value" + ], + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/Binary" + } + } + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "ibc" + ], + "properties": { + "ibc": { + "$ref": "#/definitions/IbcMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "wasm" + ], + "properties": { + "wasm": { + "$ref": "#/definitions/WasmMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "gov" + ], + "properties": { + "gov": { + "$ref": "#/definitions/GovMsg" + } + }, + "additionalProperties": false + } + ] + }, + "Decimal": { + "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", + "type": "string" + }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" ], "properties": { - "staking": { - "$ref": "#/definitions/StakingMsg" + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", "type": "object", "required": [ - "distribution" + "withdrawal" ], "properties": { - "distribution": { - "$ref": "#/definitions/DistributionMsg" + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } } }, "additionalProperties": false }, { - "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", "type": "object", "required": [ - "stargate" + "place_limit_order" ], "properties": { - "stargate": { + "place_limit_order": { "type": "object", "required": [ - "type_url", - "value" + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" ], "properties": { - "type_url": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", "type": "string" }, - "value": { - "$ref": "#/definitions/Binary" + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" } } } @@ -3851,47 +4666,104 @@ "additionalProperties": false }, { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", "type": "object", "required": [ - "ibc" + "withdraw_filled_limit_order" ], "properties": { - "ibc": { - "$ref": "#/definitions/IbcMsg" + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", "type": "object", "required": [ - "wasm" + "cancel_limit_order" ], "properties": { - "wasm": { - "$ref": "#/definitions/WasmMsg" + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", "type": "object", "required": [ - "gov" + "multi_hop_swap" ], "properties": { - "gov": { - "$ref": "#/definitions/GovMsg" + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } } }, "additionalProperties": false } ] }, - "Decimal": { - "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", - "type": "string" - }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -4232,6 +5104,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -4250,6 +5161,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "MultipleChoiceOptionType": { "description": "Represents the type of Multiple choice option. \"None of the above\" has a special type for example.", "oneOf": [ @@ -4782,23 +5707,116 @@ "additionalProperties": false }, { - "description": "TokenFactory message. Contracts can set before send hooks for denoms, namespaced under the contract's address.", + "description": "TokenFactory message. Contracts can set before send hooks for denoms, namespaced under the contract's address.", + "type": "object", + "required": [ + "set_before_send_hook" + ], + "properties": { + "set_before_send_hook": { + "type": "object", + "required": [ + "contract_addr", + "denom" + ], + "properties": { + "contract_addr": { + "type": "string" + }, + "denom": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", "type": "object", "required": [ - "set_before_send_hook" + "set_denom_metadata" ], "properties": { - "set_before_send_hook": { + "set_denom_metadata": { "type": "object", "required": [ - "contract_addr", - "denom" + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" ], "properties": { - "contract_addr": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", "type": "string" }, - "denom": { + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", "type": "string" } } @@ -4886,6 +5904,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -5022,6 +6053,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", @@ -5953,6 +6995,7 @@ "description", "index", "option_type", + "title", "vote_count" ], "properties": { @@ -5976,6 +7019,9 @@ "option_type": { "$ref": "#/definitions/MultipleChoiceOptionType" }, + "title": { + "type": "string" + }, "vote_count": { "$ref": "#/definitions/Uint128" } @@ -6161,10 +7207,357 @@ } ] }, - "Decimal": { - "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", - "type": "string" - }, + "Decimal": { + "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", + "type": "string" + }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -6505,6 +7898,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -6523,6 +7955,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "MultipleChoiceOptionType": { "description": "Represents the type of Multiple choice option. \"None of the above\" has a special type for example.", "oneOf": [ @@ -7079,6 +8525,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -7159,6 +8698,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -7295,6 +8847,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", @@ -8203,6 +9766,7 @@ "description", "index", "option_type", + "title", "vote_count" ], "properties": { @@ -8226,6 +9790,9 @@ "option_type": { "$ref": "#/definitions/MultipleChoiceOptionType" }, + "title": { + "type": "string" + }, "vote_count": { "$ref": "#/definitions/Uint128" } @@ -8339,34 +9906,324 @@ { "type": "object", "required": [ - "distribution" + "distribution" + ], + "properties": { + "distribution": { + "$ref": "#/definitions/DistributionMsg" + } + }, + "additionalProperties": false + }, + { + "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "type": "object", + "required": [ + "stargate" + ], + "properties": { + "stargate": { + "type": "object", + "required": [ + "type_url", + "value" + ], + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/Binary" + } + } + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "ibc" + ], + "properties": { + "ibc": { + "$ref": "#/definitions/IbcMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "wasm" + ], + "properties": { + "wasm": { + "$ref": "#/definitions/WasmMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "gov" + ], + "properties": { + "gov": { + "$ref": "#/definitions/GovMsg" + } + }, + "additionalProperties": false + } + ] + }, + "Decimal": { + "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", + "type": "string" + }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" ], "properties": { - "distribution": { - "$ref": "#/definitions/DistributionMsg" + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } } }, "additionalProperties": false }, { - "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", "type": "object", "required": [ - "stargate" + "place_limit_order" ], "properties": { - "stargate": { + "place_limit_order": { "type": "object", "required": [ - "type_url", - "value" + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" ], "properties": { - "type_url": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", "type": "string" }, - "value": { - "$ref": "#/definitions/Binary" + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" } } } @@ -8374,47 +10231,104 @@ "additionalProperties": false }, { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", "type": "object", "required": [ - "ibc" + "withdraw_filled_limit_order" ], "properties": { - "ibc": { - "$ref": "#/definitions/IbcMsg" + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", "type": "object", "required": [ - "wasm" + "cancel_limit_order" ], "properties": { - "wasm": { - "$ref": "#/definitions/WasmMsg" + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", "type": "object", "required": [ - "gov" + "multi_hop_swap" ], "properties": { - "gov": { - "$ref": "#/definitions/GovMsg" + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } } }, "additionalProperties": false } ] }, - "Decimal": { - "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", - "type": "string" - }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -8755,6 +10669,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -8773,6 +10726,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "MultipleChoiceOptionType": { "description": "Represents the type of Multiple choice option. \"None of the above\" has a special type for example.", "oneOf": [ @@ -9329,6 +11296,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -9409,6 +11469,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -9545,6 +11618,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/execute.json b/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/execute.json index 5b00cac2..6f439e90 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/execute.json +++ b/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/execute.json @@ -763,6 +763,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -1090,6 +1437,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "ModuleInstantiateInfo": { "description": "Information needed to instantiate a module.", "type": "object", @@ -1148,11 +1534,26 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "MultipleChoiceOption": { "description": "Unchecked multiple choice option", "type": "object", "required": [ - "description" + "description", + "title" ], "properties": { "description": { @@ -1166,6 +1567,9 @@ "items": { "$ref": "#/definitions/CosmosMsg_for_NeutronMsg" } + }, + "title": { + "type": "string" } } }, @@ -1621,6 +2025,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1701,6 +2198,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1875,6 +2385,17 @@ } ] }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/response_to_list_proposals.json b/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/response_to_list_proposals.json index 370208a5..623f7bfc 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/response_to_list_proposals.json +++ b/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/response_to_list_proposals.json @@ -261,6 +261,7 @@ "description", "index", "option_type", + "title", "vote_count" ], "properties": { @@ -284,6 +285,9 @@ "option_type": { "$ref": "#/definitions/MultipleChoiceOptionType" }, + "title": { + "type": "string" + }, "vote_count": { "$ref": "#/definitions/Uint128" } @@ -473,6 +477,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -813,6 +1164,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -831,6 +1221,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "MultipleChoiceOptionType": { "description": "Represents the type of Multiple choice option. \"None of the above\" has a special type for example.", "oneOf": [ @@ -1387,6 +1791,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1467,6 +1964,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1603,6 +2113,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/response_to_proposal.json b/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/response_to_proposal.json index 268c0c9b..05bd4197 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/response_to_proposal.json +++ b/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/response_to_proposal.json @@ -265,6 +265,7 @@ "description", "index", "option_type", + "title", "vote_count" ], "properties": { @@ -288,6 +289,9 @@ "option_type": { "$ref": "#/definitions/MultipleChoiceOptionType" }, + "title": { + "type": "string" + }, "vote_count": { "$ref": "#/definitions/Uint128" } @@ -477,6 +481,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -817,6 +1168,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -835,6 +1225,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "MultipleChoiceOptionType": { "description": "Represents the type of Multiple choice option. \"None of the above\" has a special type for example.", "oneOf": [ @@ -1391,6 +1795,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1471,6 +1968,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1607,6 +2117,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/response_to_reverse_proposals.json b/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/response_to_reverse_proposals.json index 370208a5..623f7bfc 100644 --- a/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/response_to_reverse_proposals.json +++ b/contracts/dao/proposal/cwd-proposal-multiple/schema/raw/response_to_reverse_proposals.json @@ -261,6 +261,7 @@ "description", "index", "option_type", + "title", "vote_count" ], "properties": { @@ -284,6 +285,9 @@ "option_type": { "$ref": "#/definitions/MultipleChoiceOptionType" }, + "title": { + "type": "string" + }, "vote_count": { "$ref": "#/definitions/Uint128" } @@ -473,6 +477,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -813,6 +1164,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -831,6 +1221,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "MultipleChoiceOptionType": { "description": "Represents the type of Multiple choice option. \"None of the above\" has a special type for example.", "oneOf": [ @@ -1387,6 +1791,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1467,6 +1964,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1603,6 +2113,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/proposal/cwd-proposal-single/schema/cwd-proposal-single.json b/contracts/dao/proposal/cwd-proposal-single/schema/cwd-proposal-single.json index 58eae03c..e629adff 100644 --- a/contracts/dao/proposal/cwd-proposal-single/schema/cwd-proposal-single.json +++ b/contracts/dao/proposal/cwd-proposal-single/schema/cwd-proposal-single.json @@ -1,6 +1,6 @@ { "contract_name": "cwd-proposal-single", - "contract_version": "0.2.1", + "contract_version": "0.2.2", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", @@ -1080,6 +1080,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -1407,6 +1754,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "ModuleInstantiateInfo": { "description": "Information needed to instantiate a module.", "type": "object", @@ -1465,6 +1851,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1888,6 +2288,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1968,6 +2461,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -2142,6 +2648,17 @@ } ] }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", @@ -3719,46 +4236,336 @@ { "type": "object", "required": [ - "staking" + "staking" + ], + "properties": { + "staking": { + "$ref": "#/definitions/StakingMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "distribution" + ], + "properties": { + "distribution": { + "$ref": "#/definitions/DistributionMsg" + } + }, + "additionalProperties": false + }, + { + "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "type": "object", + "required": [ + "stargate" + ], + "properties": { + "stargate": { + "type": "object", + "required": [ + "type_url", + "value" + ], + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/Binary" + } + } + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "ibc" + ], + "properties": { + "ibc": { + "$ref": "#/definitions/IbcMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "wasm" + ], + "properties": { + "wasm": { + "$ref": "#/definitions/WasmMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "gov" + ], + "properties": { + "gov": { + "$ref": "#/definitions/GovMsg" + } + }, + "additionalProperties": false + } + ] + }, + "Decimal": { + "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", + "type": "string" + }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" ], "properties": { - "staking": { - "$ref": "#/definitions/StakingMsg" + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", "type": "object", "required": [ - "distribution" + "withdrawal" ], "properties": { - "distribution": { - "$ref": "#/definitions/DistributionMsg" + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } } }, "additionalProperties": false }, { - "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", "type": "object", "required": [ - "stargate" + "place_limit_order" ], "properties": { - "stargate": { + "place_limit_order": { "type": "object", "required": [ - "type_url", - "value" + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" ], "properties": { - "type_url": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", "type": "string" }, - "value": { - "$ref": "#/definitions/Binary" + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" } } } @@ -3766,47 +4573,104 @@ "additionalProperties": false }, { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", "type": "object", "required": [ - "ibc" + "withdraw_filled_limit_order" ], "properties": { - "ibc": { - "$ref": "#/definitions/IbcMsg" + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", "type": "object", "required": [ - "wasm" + "cancel_limit_order" ], "properties": { - "wasm": { - "$ref": "#/definitions/WasmMsg" + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", "type": "object", "required": [ - "gov" + "multi_hop_swap" ], "properties": { - "gov": { - "$ref": "#/definitions/GovMsg" + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } } }, "additionalProperties": false } ] }, - "Decimal": { - "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", - "type": "string" - }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -4147,6 +5011,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -4165,6 +5068,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -4540,22 +5457,80 @@ "burn_tokens" ], "properties": { - "burn_tokens": { + "burn_tokens": { + "type": "object", + "required": [ + "amount", + "burn_from_address", + "denom" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "burn_from_address": { + "description": "Must be set to `\"\"` for now", + "type": "string" + }, + "denom": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactory message. Contracts can set before send hooks for denoms, namespaced under the contract's address.", + "type": "object", + "required": [ + "set_before_send_hook" + ], + "properties": { + "set_before_send_hook": { + "type": "object", + "required": [ + "contract_addr", + "denom" + ], + "properties": { + "contract_addr": { + "type": "string" + }, + "denom": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { "type": "object", "required": [ "amount", - "burn_from_address", - "denom" + "denom", + "transfer_from_address", + "transfer_to_address" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, - "burn_from_address": { - "description": "Must be set to `\"\"` for now", + "denom": { "type": "string" }, - "denom": { + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { "type": "string" } } @@ -4564,23 +5539,58 @@ "additionalProperties": false }, { - "description": "TokenFactory message. Contracts can set before send hooks for denoms, namespaced under the contract's address.", + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", "type": "object", "required": [ - "set_before_send_hook" + "set_denom_metadata" ], "properties": { - "set_before_send_hook": { + "set_denom_metadata": { "type": "object", "required": [ - "contract_addr", - "denom" + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" ], "properties": { - "contract_addr": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", "type": "string" }, - "denom": { + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", "type": "string" } } @@ -4668,6 +5678,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -4804,6 +5827,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", @@ -6073,10 +7107,357 @@ } ] }, - "Decimal": { - "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", - "type": "string" - }, + "Decimal": { + "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", + "type": "string" + }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -6417,6 +7798,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -6435,6 +7855,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -6858,6 +8292,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -6938,6 +8465,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -7074,6 +8614,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", @@ -8238,34 +9789,324 @@ { "type": "object", "required": [ - "distribution" + "distribution" + ], + "properties": { + "distribution": { + "$ref": "#/definitions/DistributionMsg" + } + }, + "additionalProperties": false + }, + { + "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "type": "object", + "required": [ + "stargate" + ], + "properties": { + "stargate": { + "type": "object", + "required": [ + "type_url", + "value" + ], + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/Binary" + } + } + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "ibc" + ], + "properties": { + "ibc": { + "$ref": "#/definitions/IbcMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "wasm" + ], + "properties": { + "wasm": { + "$ref": "#/definitions/WasmMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "gov" + ], + "properties": { + "gov": { + "$ref": "#/definitions/GovMsg" + } + }, + "additionalProperties": false + } + ] + }, + "Decimal": { + "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", + "type": "string" + }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" ], "properties": { - "distribution": { - "$ref": "#/definitions/DistributionMsg" + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } } }, "additionalProperties": false }, { - "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", "type": "object", "required": [ - "stargate" + "place_limit_order" ], "properties": { - "stargate": { + "place_limit_order": { "type": "object", "required": [ - "type_url", - "value" + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" ], "properties": { - "type_url": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", "type": "string" }, - "value": { - "$ref": "#/definitions/Binary" + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" } } } @@ -8273,47 +10114,104 @@ "additionalProperties": false }, { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", "type": "object", "required": [ - "ibc" + "withdraw_filled_limit_order" ], "properties": { - "ibc": { - "$ref": "#/definitions/IbcMsg" + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", "type": "object", "required": [ - "wasm" + "cancel_limit_order" ], "properties": { - "wasm": { - "$ref": "#/definitions/WasmMsg" + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", "type": "object", "required": [ - "gov" + "multi_hop_swap" ], "properties": { - "gov": { - "$ref": "#/definitions/GovMsg" + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } } }, "additionalProperties": false } ] }, - "Decimal": { - "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", - "type": "string" - }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -8654,6 +10552,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -8672,6 +10609,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -9095,6 +11046,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -9175,6 +11219,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -9311,6 +11368,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/proposal/cwd-proposal-single/schema/raw/execute.json b/contracts/dao/proposal/cwd-proposal-single/schema/raw/execute.json index b4b82a61..0832f00f 100644 --- a/contracts/dao/proposal/cwd-proposal-single/schema/raw/execute.json +++ b/contracts/dao/proposal/cwd-proposal-single/schema/raw/execute.json @@ -751,6 +751,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -1078,6 +1425,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "ModuleInstantiateInfo": { "description": "Information needed to instantiate a module.", "type": "object", @@ -1136,6 +1522,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1559,6 +1959,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1639,6 +2132,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1813,6 +2319,17 @@ } ] }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/proposal/cwd-proposal-single/schema/raw/response_to_list_proposals.json b/contracts/dao/proposal/cwd-proposal-single/schema/raw/response_to_list_proposals.json index e3609c7c..c9e99265 100644 --- a/contracts/dao/proposal/cwd-proposal-single/schema/raw/response_to_list_proposals.json +++ b/contracts/dao/proposal/cwd-proposal-single/schema/raw/response_to_list_proposals.json @@ -438,6 +438,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -778,6 +1125,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -796,6 +1182,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1219,6 +1619,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1299,6 +1792,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1435,6 +1941,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/proposal/cwd-proposal-single/schema/raw/response_to_proposal.json b/contracts/dao/proposal/cwd-proposal-single/schema/raw/response_to_proposal.json index 1d4cd442..a8362cfd 100644 --- a/contracts/dao/proposal/cwd-proposal-single/schema/raw/response_to_proposal.json +++ b/contracts/dao/proposal/cwd-proposal-single/schema/raw/response_to_proposal.json @@ -442,6 +442,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -782,6 +1129,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -800,6 +1186,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1223,6 +1623,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1303,6 +1796,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1439,6 +1945,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/proposal/cwd-proposal-single/schema/raw/response_to_reverse_proposals.json b/contracts/dao/proposal/cwd-proposal-single/schema/raw/response_to_reverse_proposals.json index e3609c7c..c9e99265 100644 --- a/contracts/dao/proposal/cwd-proposal-single/schema/raw/response_to_reverse_proposals.json +++ b/contracts/dao/proposal/cwd-proposal-single/schema/raw/response_to_reverse_proposals.json @@ -438,6 +438,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -778,6 +1125,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -796,6 +1182,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1219,6 +1619,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1299,6 +1792,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1435,6 +1941,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/dao/voting/credits-vault/schema/credits-vault.json b/contracts/dao/voting/credits-vault/schema/credits-vault.json index ef3dc990..26f3fab4 100644 --- a/contracts/dao/voting/credits-vault/schema/credits-vault.json +++ b/contracts/dao/voting/credits-vault/schema/credits-vault.json @@ -1,6 +1,6 @@ { "contract_name": "credits-vault", - "contract_version": "0.2.0", + "contract_version": "0.2.1", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", diff --git a/contracts/dao/voting/investors-vesting-vault/schema/investors-vesting-vault.json b/contracts/dao/voting/investors-vesting-vault/schema/investors-vesting-vault.json index 68feb7ac..f3b7d3ba 100644 --- a/contracts/dao/voting/investors-vesting-vault/schema/investors-vesting-vault.json +++ b/contracts/dao/voting/investors-vesting-vault/schema/investors-vesting-vault.json @@ -1,6 +1,6 @@ { "contract_name": "investors-vesting-vault", - "contract_version": "0.2.0", + "contract_version": "0.2.1", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", diff --git a/contracts/dao/voting/lockdrop-vault/schema/lockdrop-vault.json b/contracts/dao/voting/lockdrop-vault/schema/lockdrop-vault.json index 204553a6..6f34104c 100644 --- a/contracts/dao/voting/lockdrop-vault/schema/lockdrop-vault.json +++ b/contracts/dao/voting/lockdrop-vault/schema/lockdrop-vault.json @@ -1,6 +1,6 @@ { "contract_name": "lockdrop-vault", - "contract_version": "0.1.0", + "contract_version": "0.1.1", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", diff --git a/contracts/dao/voting/neutron-vault/schema/neutron-vault.json b/contracts/dao/voting/neutron-vault/schema/neutron-vault.json index 9d631bce..d5583ddd 100644 --- a/contracts/dao/voting/neutron-vault/schema/neutron-vault.json +++ b/contracts/dao/voting/neutron-vault/schema/neutron-vault.json @@ -1,6 +1,6 @@ { "contract_name": "neutron-vault", - "contract_version": "0.2.0", + "contract_version": "0.2.1", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", diff --git a/contracts/dao/voting/neutron-voting-registry/schema/neutron-voting-registry.json b/contracts/dao/voting/neutron-voting-registry/schema/neutron-voting-registry.json index 9ee574fa..d56ac283 100644 --- a/contracts/dao/voting/neutron-voting-registry/schema/neutron-voting-registry.json +++ b/contracts/dao/voting/neutron-voting-registry/schema/neutron-voting-registry.json @@ -1,6 +1,6 @@ { "contract_name": "neutron-voting-registry", - "contract_version": "0.3.0", + "contract_version": "0.3.1", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", diff --git a/contracts/dao/voting/vesting-lp-vault/schema/vesting-lp-vault.json b/contracts/dao/voting/vesting-lp-vault/schema/vesting-lp-vault.json index 40f395c4..cc695954 100644 --- a/contracts/dao/voting/vesting-lp-vault/schema/vesting-lp-vault.json +++ b/contracts/dao/voting/vesting-lp-vault/schema/vesting-lp-vault.json @@ -1,6 +1,6 @@ { "contract_name": "vesting-lp-vault", - "contract_version": "0.1.0", + "contract_version": "0.1.1", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", diff --git a/contracts/subdaos/cwd-subdao-core/schema/cwd-subdao-core.json b/contracts/subdaos/cwd-subdao-core/schema/cwd-subdao-core.json index 0dc64934..1394871e 100644 --- a/contracts/subdaos/cwd-subdao-core/schema/cwd-subdao-core.json +++ b/contracts/subdaos/cwd-subdao-core/schema/cwd-subdao-core.json @@ -1,6 +1,6 @@ { "contract_name": "cwd-subdao-core", - "contract_version": "0.2.1", + "contract_version": "0.2.2", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", @@ -848,6 +848,353 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "GovMsg": { "description": "This message type allows the contract interact with the [x/gov] module in order to cast votes.\n\n[x/gov]: https://github.com/cosmos/cosmos-sdk/tree/v0.45.12/x/gov\n\n## Examples\n\nCast a simple vote:\n\n``` # use cosmwasm_std::{ # HexBinary, # Storage, Api, Querier, DepsMut, Deps, entry_point, Env, StdError, MessageInfo, # Response, QueryResponse, # }; # type ExecuteMsg = (); use cosmwasm_std::{GovMsg, VoteOption};\n\n#[entry_point] pub fn execute( deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, ) -> Result { // ... Ok(Response::new().add_message(GovMsg::Vote { proposal_id: 4, vote: VoteOption::Yes, })) } ```\n\nCast a weighted vote:\n\n``` # use cosmwasm_std::{ # HexBinary, # Storage, Api, Querier, DepsMut, Deps, entry_point, Env, StdError, MessageInfo, # Response, QueryResponse, # }; # type ExecuteMsg = (); # #[cfg(feature = \"cosmwasm_1_2\")] use cosmwasm_std::{Decimal, GovMsg, VoteOption, WeightedVoteOption};\n\n# #[cfg(feature = \"cosmwasm_1_2\")] #[entry_point] pub fn execute( deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, ) -> Result { // ... Ok(Response::new().add_message(GovMsg::VoteWeighted { proposal_id: 4, options: vec![ WeightedVoteOption { option: VoteOption::Yes, weight: Decimal::percent(65), }, WeightedVoteOption { option: VoteOption::Abstain, weight: Decimal::percent(35), }, ], })) } ```", "oneOf": [ @@ -1092,6 +1439,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "ModuleInstantiateInfo": { "description": "Information needed to instantiate a module.", "type": "object", @@ -1150,6 +1536,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1573,6 +1973,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1653,6 +2146,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1758,6 +2264,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/cwd-subdao-core/schema/raw/execute.json b/contracts/subdaos/cwd-subdao-core/schema/raw/execute.json index 496a9649..de147acd 100644 --- a/contracts/subdaos/cwd-subdao-core/schema/raw/execute.json +++ b/contracts/subdaos/cwd-subdao-core/schema/raw/execute.json @@ -678,6 +678,353 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "GovMsg": { "description": "This message type allows the contract interact with the [x/gov] module in order to cast votes.\n\n[x/gov]: https://github.com/cosmos/cosmos-sdk/tree/v0.45.12/x/gov\n\n## Examples\n\nCast a simple vote:\n\n``` # use cosmwasm_std::{ # HexBinary, # Storage, Api, Querier, DepsMut, Deps, entry_point, Env, StdError, MessageInfo, # Response, QueryResponse, # }; # type ExecuteMsg = (); use cosmwasm_std::{GovMsg, VoteOption};\n\n#[entry_point] pub fn execute( deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, ) -> Result { // ... Ok(Response::new().add_message(GovMsg::Vote { proposal_id: 4, vote: VoteOption::Yes, })) } ```\n\nCast a weighted vote:\n\n``` # use cosmwasm_std::{ # HexBinary, # Storage, Api, Querier, DepsMut, Deps, entry_point, Env, StdError, MessageInfo, # Response, QueryResponse, # }; # type ExecuteMsg = (); # #[cfg(feature = \"cosmwasm_1_2\")] use cosmwasm_std::{Decimal, GovMsg, VoteOption, WeightedVoteOption};\n\n# #[cfg(feature = \"cosmwasm_1_2\")] #[entry_point] pub fn execute( deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, ) -> Result { // ... Ok(Response::new().add_message(GovMsg::VoteWeighted { proposal_id: 4, options: vec![ WeightedVoteOption { option: VoteOption::Yes, weight: Decimal::percent(65), }, WeightedVoteOption { option: VoteOption::Abstain, weight: Decimal::percent(35), }, ], })) } ```", "oneOf": [ @@ -922,6 +1269,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "ModuleInstantiateInfo": { "description": "Information needed to instantiate a module.", "type": "object", @@ -980,6 +1366,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1403,6 +1803,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1483,6 +1976,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1588,6 +2094,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/cwd-subdao-timelock-single/schema/cwd-subdao-timelock-single.json b/contracts/subdaos/cwd-subdao-timelock-single/schema/cwd-subdao-timelock-single.json index c86e6c27..77b4f249 100644 --- a/contracts/subdaos/cwd-subdao-timelock-single/schema/cwd-subdao-timelock-single.json +++ b/contracts/subdaos/cwd-subdao-timelock-single/schema/cwd-subdao-timelock-single.json @@ -1,6 +1,6 @@ { "contract_name": "cwd-subdao-timelock-single", - "contract_version": "0.2.1", + "contract_version": "0.2.2", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", @@ -535,6 +535,353 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -828,6 +1175,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -846,6 +1232,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1192,21 +1592,76 @@ "mint_tokens" ], "properties": { - "mint_tokens": { + "mint_tokens": { + "type": "object", + "required": [ + "amount", + "denom", + "mint_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "mint_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactory message. Contracts can burn native tokens for an existing factory denom that they are the admin of. Currently, the burn from address must be the admin contract.", + "type": "object", + "required": [ + "burn_tokens" + ], + "properties": { + "burn_tokens": { + "type": "object", + "required": [ + "amount", + "burn_from_address", + "denom" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "burn_from_address": { + "description": "Must be set to `\"\"` for now", + "type": "string" + }, + "denom": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactory message. Contracts can set before send hooks for denoms, namespaced under the contract's address.", + "type": "object", + "required": [ + "set_before_send_hook" + ], + "properties": { + "set_before_send_hook": { "type": "object", "required": [ - "amount", - "denom", - "mint_to_address" + "contract_addr", + "denom" ], "properties": { - "amount": { - "$ref": "#/definitions/Uint128" - }, - "denom": { + "contract_addr": { "type": "string" }, - "mint_to_address": { + "denom": { "type": "string" } } @@ -1215,28 +1670,31 @@ "additionalProperties": false }, { - "description": "TokenFactory message. Contracts can burn native tokens for an existing factory denom that they are the admin of. Currently, the burn from address must be the admin contract.", + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", "type": "object", "required": [ - "burn_tokens" + "force_transfer" ], "properties": { - "burn_tokens": { + "force_transfer": { "type": "object", "required": [ "amount", - "burn_from_address", - "denom" + "denom", + "transfer_from_address", + "transfer_to_address" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, - "burn_from_address": { - "description": "Must be set to `\"\"` for now", + "denom": { "type": "string" }, - "denom": { + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { "type": "string" } } @@ -1245,23 +1703,58 @@ "additionalProperties": false }, { - "description": "TokenFactory message. Contracts can set before send hooks for denoms, namespaced under the contract's address.", + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", "type": "object", "required": [ - "set_before_send_hook" + "set_denom_metadata" ], "properties": { - "set_before_send_hook": { + "set_denom_metadata": { "type": "object", "required": [ - "contract_addr", - "denom" + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" ], "properties": { - "contract_addr": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", "type": "string" }, - "denom": { + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", "type": "string" } } @@ -1349,6 +1842,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1454,6 +1960,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", @@ -2508,11 +3025,358 @@ { "type": "object", "required": [ - "gov" + "gov" + ], + "properties": { + "gov": { + "$ref": "#/definitions/GovMsg" + } + }, + "additionalProperties": false + } + ] + }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" ], "properties": { - "gov": { - "$ref": "#/definitions/GovMsg" + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } } }, "additionalProperties": false @@ -2812,6 +3676,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -2830,6 +3733,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -3253,6 +4170,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -3333,6 +4343,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -3438,6 +4461,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", @@ -4364,34 +5398,320 @@ { "type": "object", "required": [ - "distribution" + "distribution" + ], + "properties": { + "distribution": { + "$ref": "#/definitions/DistributionMsg" + } + }, + "additionalProperties": false + }, + { + "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "type": "object", + "required": [ + "stargate" + ], + "properties": { + "stargate": { + "type": "object", + "required": [ + "type_url", + "value" + ], + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/Binary" + } + } + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "ibc" + ], + "properties": { + "ibc": { + "$ref": "#/definitions/IbcMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "wasm" + ], + "properties": { + "wasm": { + "$ref": "#/definitions/WasmMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "gov" + ], + "properties": { + "gov": { + "$ref": "#/definitions/GovMsg" + } + }, + "additionalProperties": false + } + ] + }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" ], "properties": { - "distribution": { - "$ref": "#/definitions/DistributionMsg" + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } } }, "additionalProperties": false }, { - "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", "type": "object", "required": [ - "stargate" + "place_limit_order" ], "properties": { - "stargate": { + "place_limit_order": { "type": "object", "required": [ - "type_url", - "value" + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" ], "properties": { - "type_url": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", "type": "string" }, - "value": { - "$ref": "#/definitions/Binary" + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" } } } @@ -4399,37 +5719,98 @@ "additionalProperties": false }, { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", "type": "object", "required": [ - "ibc" + "withdraw_filled_limit_order" ], "properties": { - "ibc": { - "$ref": "#/definitions/IbcMsg" + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", "type": "object", "required": [ - "wasm" + "cancel_limit_order" ], "properties": { - "wasm": { - "$ref": "#/definitions/WasmMsg" + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", "type": "object", "required": [ - "gov" + "multi_hop_swap" ], "properties": { - "gov": { - "$ref": "#/definitions/GovMsg" + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } } }, "additionalProperties": false @@ -4729,6 +6110,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -4747,6 +6167,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -5170,6 +6604,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -5250,6 +6777,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -5355,6 +6895,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/cwd-subdao-timelock-single/schema/raw/execute.json b/contracts/subdaos/cwd-subdao-timelock-single/schema/raw/execute.json index b9caf19e..f82efd52 100644 --- a/contracts/subdaos/cwd-subdao-timelock-single/schema/raw/execute.json +++ b/contracts/subdaos/cwd-subdao-timelock-single/schema/raw/execute.json @@ -518,6 +518,353 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -811,6 +1158,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -829,6 +1215,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1252,6 +1652,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1332,6 +1825,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1437,6 +1943,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/cwd-subdao-timelock-single/schema/raw/response_to_list_proposals.json b/contracts/subdaos/cwd-subdao-timelock-single/schema/raw/response_to_list_proposals.json index e1bd19cd..5c8f71ae 100644 --- a/contracts/subdaos/cwd-subdao-timelock-single/schema/raw/response_to_list_proposals.json +++ b/contracts/subdaos/cwd-subdao-timelock-single/schema/raw/response_to_list_proposals.json @@ -430,6 +430,353 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -723,6 +1070,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -741,6 +1127,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1164,6 +1564,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1244,6 +1737,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1349,6 +1855,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/cwd-subdao-timelock-single/schema/raw/response_to_proposal.json b/contracts/subdaos/cwd-subdao-timelock-single/schema/raw/response_to_proposal.json index e0c9e081..642b472b 100644 --- a/contracts/subdaos/cwd-subdao-timelock-single/schema/raw/response_to_proposal.json +++ b/contracts/subdaos/cwd-subdao-timelock-single/schema/raw/response_to_proposal.json @@ -441,6 +441,353 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -734,6 +1081,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -752,6 +1138,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1175,6 +1575,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1255,6 +1748,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1360,6 +1866,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/pre-propose/cwd-security-subdao-pre-propose/schema/cwd-security-subdao-pre-propose.json b/contracts/subdaos/pre-propose/cwd-security-subdao-pre-propose/schema/cwd-security-subdao-pre-propose.json index 4078fe4c..a5f5ae25 100644 --- a/contracts/subdaos/pre-propose/cwd-security-subdao-pre-propose/schema/cwd-security-subdao-pre-propose.json +++ b/contracts/subdaos/pre-propose/cwd-security-subdao-pre-propose/schema/cwd-security-subdao-pre-propose.json @@ -1,6 +1,6 @@ { "contract_name": "cwd-security-subdao-pre-propose", - "contract_version": "0.2.1", + "contract_version": "0.2.2", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", @@ -692,6 +692,42 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, "DepositRefundPolicy": { "oneOf": [ { @@ -756,6 +792,317 @@ } ] }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "GovMsg": { "description": "This message type allows the contract interact with the [x/gov] module in order to cast votes.\n\n[x/gov]: https://github.com/cosmos/cosmos-sdk/tree/v0.45.12/x/gov\n\n## Examples\n\nCast a simple vote:\n\n``` # use cosmwasm_std::{ # HexBinary, # Storage, Api, Querier, DepsMut, Deps, entry_point, Env, StdError, MessageInfo, # Response, QueryResponse, # }; # type ExecuteMsg = (); use cosmwasm_std::{GovMsg, VoteOption};\n\n#[entry_point] pub fn execute( deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, ) -> Result { // ... Ok(Response::new().add_message(GovMsg::Vote { proposal_id: 4, vote: VoteOption::Yes, })) } ```\n\nCast a weighted vote:\n\n``` # use cosmwasm_std::{ # HexBinary, # Storage, Api, Querier, DepsMut, Deps, entry_point, Env, StdError, MessageInfo, # Response, QueryResponse, # }; # type ExecuteMsg = (); # #[cfg(feature = \"cosmwasm_1_2\")] use cosmwasm_std::{Decimal, GovMsg, VoteOption, WeightedVoteOption};\n\n# #[cfg(feature = \"cosmwasm_1_2\")] #[entry_point] pub fn execute( deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, ) -> Result { // ... Ok(Response::new().add_message(GovMsg::VoteWeighted { proposal_id: 4, options: vec![ WeightedVoteOption { option: VoteOption::Yes, weight: Decimal::percent(65), }, WeightedVoteOption { option: VoteOption::Abstain, weight: Decimal::percent(35), }, ], })) } ```", "oneOf": [ @@ -1000,6 +1347,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -1018,6 +1404,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1441,6 +1841,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1521,6 +2014,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1626,6 +2132,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/pre-propose/cwd-security-subdao-pre-propose/schema/raw/execute.json b/contracts/subdaos/pre-propose/cwd-security-subdao-pre-propose/schema/raw/execute.json index 7af16881..3a849e7e 100644 --- a/contracts/subdaos/pre-propose/cwd-security-subdao-pre-propose/schema/raw/execute.json +++ b/contracts/subdaos/pre-propose/cwd-security-subdao-pre-propose/schema/raw/execute.json @@ -527,6 +527,42 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, "DepositRefundPolicy": { "oneOf": [ { @@ -591,6 +627,317 @@ } ] }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "GovMsg": { "description": "This message type allows the contract interact with the [x/gov] module in order to cast votes.\n\n[x/gov]: https://github.com/cosmos/cosmos-sdk/tree/v0.45.12/x/gov\n\n## Examples\n\nCast a simple vote:\n\n``` # use cosmwasm_std::{ # HexBinary, # Storage, Api, Querier, DepsMut, Deps, entry_point, Env, StdError, MessageInfo, # Response, QueryResponse, # }; # type ExecuteMsg = (); use cosmwasm_std::{GovMsg, VoteOption};\n\n#[entry_point] pub fn execute( deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, ) -> Result { // ... Ok(Response::new().add_message(GovMsg::Vote { proposal_id: 4, vote: VoteOption::Yes, })) } ```\n\nCast a weighted vote:\n\n``` # use cosmwasm_std::{ # HexBinary, # Storage, Api, Querier, DepsMut, Deps, entry_point, Env, StdError, MessageInfo, # Response, QueryResponse, # }; # type ExecuteMsg = (); # #[cfg(feature = \"cosmwasm_1_2\")] use cosmwasm_std::{Decimal, GovMsg, VoteOption, WeightedVoteOption};\n\n# #[cfg(feature = \"cosmwasm_1_2\")] #[entry_point] pub fn execute( deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, ) -> Result { // ... Ok(Response::new().add_message(GovMsg::VoteWeighted { proposal_id: 4, options: vec![ WeightedVoteOption { option: VoteOption::Yes, weight: Decimal::percent(65), }, WeightedVoteOption { option: VoteOption::Abstain, weight: Decimal::percent(35), }, ], })) } ```", "oneOf": [ @@ -835,6 +1182,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -853,6 +1239,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1276,6 +1676,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1356,6 +1849,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1461,6 +1967,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/pre-propose/cwd-subdao-pre-propose-single/schema/cwd-subdao-pre-propose-single.json b/contracts/subdaos/pre-propose/cwd-subdao-pre-propose-single/schema/cwd-subdao-pre-propose-single.json index 1a8ad0f9..15d2adcf 100644 --- a/contracts/subdaos/pre-propose/cwd-subdao-pre-propose-single/schema/cwd-subdao-pre-propose-single.json +++ b/contracts/subdaos/pre-propose/cwd-subdao-pre-propose-single/schema/cwd-subdao-pre-propose-single.json @@ -1,6 +1,6 @@ { "contract_name": "cwd-subdao-pre-propose-single", - "contract_version": "0.2.1", + "contract_version": "0.2.2", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", @@ -692,6 +692,42 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, "DepositRefundPolicy": { "oneOf": [ { @@ -756,6 +792,317 @@ } ] }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "GovMsg": { "description": "This message type allows the contract interact with the [x/gov] module in order to cast votes.\n\n[x/gov]: https://github.com/cosmos/cosmos-sdk/tree/v0.45.12/x/gov\n\n## Examples\n\nCast a simple vote:\n\n``` # use cosmwasm_std::{ # HexBinary, # Storage, Api, Querier, DepsMut, Deps, entry_point, Env, StdError, MessageInfo, # Response, QueryResponse, # }; # type ExecuteMsg = (); use cosmwasm_std::{GovMsg, VoteOption};\n\n#[entry_point] pub fn execute( deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, ) -> Result { // ... Ok(Response::new().add_message(GovMsg::Vote { proposal_id: 4, vote: VoteOption::Yes, })) } ```\n\nCast a weighted vote:\n\n``` # use cosmwasm_std::{ # HexBinary, # Storage, Api, Querier, DepsMut, Deps, entry_point, Env, StdError, MessageInfo, # Response, QueryResponse, # }; # type ExecuteMsg = (); # #[cfg(feature = \"cosmwasm_1_2\")] use cosmwasm_std::{Decimal, GovMsg, VoteOption, WeightedVoteOption};\n\n# #[cfg(feature = \"cosmwasm_1_2\")] #[entry_point] pub fn execute( deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, ) -> Result { // ... Ok(Response::new().add_message(GovMsg::VoteWeighted { proposal_id: 4, options: vec![ WeightedVoteOption { option: VoteOption::Yes, weight: Decimal::percent(65), }, WeightedVoteOption { option: VoteOption::Abstain, weight: Decimal::percent(35), }, ], })) } ```", "oneOf": [ @@ -1000,6 +1347,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -1018,6 +1404,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1441,6 +1841,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1521,6 +2014,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1626,6 +2132,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/pre-propose/cwd-subdao-pre-propose-single/schema/raw/execute.json b/contracts/subdaos/pre-propose/cwd-subdao-pre-propose-single/schema/raw/execute.json index 7af16881..3a849e7e 100644 --- a/contracts/subdaos/pre-propose/cwd-subdao-pre-propose-single/schema/raw/execute.json +++ b/contracts/subdaos/pre-propose/cwd-subdao-pre-propose-single/schema/raw/execute.json @@ -527,6 +527,42 @@ } ] }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, "DepositRefundPolicy": { "oneOf": [ { @@ -591,6 +627,317 @@ } ] }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "GovMsg": { "description": "This message type allows the contract interact with the [x/gov] module in order to cast votes.\n\n[x/gov]: https://github.com/cosmos/cosmos-sdk/tree/v0.45.12/x/gov\n\n## Examples\n\nCast a simple vote:\n\n``` # use cosmwasm_std::{ # HexBinary, # Storage, Api, Querier, DepsMut, Deps, entry_point, Env, StdError, MessageInfo, # Response, QueryResponse, # }; # type ExecuteMsg = (); use cosmwasm_std::{GovMsg, VoteOption};\n\n#[entry_point] pub fn execute( deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, ) -> Result { // ... Ok(Response::new().add_message(GovMsg::Vote { proposal_id: 4, vote: VoteOption::Yes, })) } ```\n\nCast a weighted vote:\n\n``` # use cosmwasm_std::{ # HexBinary, # Storage, Api, Querier, DepsMut, Deps, entry_point, Env, StdError, MessageInfo, # Response, QueryResponse, # }; # type ExecuteMsg = (); # #[cfg(feature = \"cosmwasm_1_2\")] use cosmwasm_std::{Decimal, GovMsg, VoteOption, WeightedVoteOption};\n\n# #[cfg(feature = \"cosmwasm_1_2\")] #[entry_point] pub fn execute( deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg, ) -> Result { // ... Ok(Response::new().add_message(GovMsg::VoteWeighted { proposal_id: 4, options: vec![ WeightedVoteOption { option: VoteOption::Yes, weight: Decimal::percent(65), }, WeightedVoteOption { option: VoteOption::Abstain, weight: Decimal::percent(35), }, ], })) } ```", "oneOf": [ @@ -835,6 +1182,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -853,6 +1239,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1276,6 +1676,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1356,6 +1849,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1461,6 +1967,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/cwd-subdao-proposal-single.json b/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/cwd-subdao-proposal-single.json index 41e1f13d..c653ef99 100644 --- a/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/cwd-subdao-proposal-single.json +++ b/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/cwd-subdao-proposal-single.json @@ -1,6 +1,6 @@ { "contract_name": "cwd-subdao-proposal-single", - "contract_version": "0.2.1", + "contract_version": "0.2.2", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", @@ -1080,6 +1080,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -1407,6 +1754,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "ModuleInstantiateInfo": { "description": "Information needed to instantiate a module.", "type": "object", @@ -1465,6 +1851,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1888,6 +2288,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1968,6 +2461,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -2142,6 +2648,17 @@ } ] }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", @@ -3695,46 +4212,336 @@ { "type": "object", "required": [ - "staking" + "staking" + ], + "properties": { + "staking": { + "$ref": "#/definitions/StakingMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "distribution" + ], + "properties": { + "distribution": { + "$ref": "#/definitions/DistributionMsg" + } + }, + "additionalProperties": false + }, + { + "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "type": "object", + "required": [ + "stargate" + ], + "properties": { + "stargate": { + "type": "object", + "required": [ + "type_url", + "value" + ], + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/Binary" + } + } + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "ibc" + ], + "properties": { + "ibc": { + "$ref": "#/definitions/IbcMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "wasm" + ], + "properties": { + "wasm": { + "$ref": "#/definitions/WasmMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "gov" + ], + "properties": { + "gov": { + "$ref": "#/definitions/GovMsg" + } + }, + "additionalProperties": false + } + ] + }, + "Decimal": { + "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", + "type": "string" + }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" ], "properties": { - "staking": { - "$ref": "#/definitions/StakingMsg" + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", "type": "object", "required": [ - "distribution" + "withdrawal" ], "properties": { - "distribution": { - "$ref": "#/definitions/DistributionMsg" + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } } }, "additionalProperties": false }, { - "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", "type": "object", "required": [ - "stargate" + "place_limit_order" ], "properties": { - "stargate": { + "place_limit_order": { "type": "object", "required": [ - "type_url", - "value" + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" ], "properties": { - "type_url": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", "type": "string" }, - "value": { - "$ref": "#/definitions/Binary" + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" } } } @@ -3742,47 +4549,104 @@ "additionalProperties": false }, { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", "type": "object", "required": [ - "ibc" + "withdraw_filled_limit_order" ], "properties": { - "ibc": { - "$ref": "#/definitions/IbcMsg" + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", "type": "object", "required": [ - "wasm" + "cancel_limit_order" ], "properties": { - "wasm": { - "$ref": "#/definitions/WasmMsg" + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", "type": "object", "required": [ - "gov" + "multi_hop_swap" ], "properties": { - "gov": { - "$ref": "#/definitions/GovMsg" + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } } }, "additionalProperties": false } ] }, - "Decimal": { - "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", - "type": "string" - }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -4123,6 +4987,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -4141,6 +5044,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -4516,22 +5433,80 @@ "burn_tokens" ], "properties": { - "burn_tokens": { + "burn_tokens": { + "type": "object", + "required": [ + "amount", + "burn_from_address", + "denom" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "burn_from_address": { + "description": "Must be set to `\"\"` for now", + "type": "string" + }, + "denom": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactory message. Contracts can set before send hooks for denoms, namespaced under the contract's address.", + "type": "object", + "required": [ + "set_before_send_hook" + ], + "properties": { + "set_before_send_hook": { + "type": "object", + "required": [ + "contract_addr", + "denom" + ], + "properties": { + "contract_addr": { + "type": "string" + }, + "denom": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { "type": "object", "required": [ "amount", - "burn_from_address", - "denom" + "denom", + "transfer_from_address", + "transfer_to_address" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, - "burn_from_address": { - "description": "Must be set to `\"\"` for now", + "denom": { "type": "string" }, - "denom": { + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { "type": "string" } } @@ -4540,23 +5515,58 @@ "additionalProperties": false }, { - "description": "TokenFactory message. Contracts can set before send hooks for denoms, namespaced under the contract's address.", + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", "type": "object", "required": [ - "set_before_send_hook" + "set_denom_metadata" ], "properties": { - "set_before_send_hook": { + "set_denom_metadata": { "type": "object", "required": [ - "contract_addr", - "denom" + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" ], "properties": { - "contract_addr": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", "type": "string" }, - "denom": { + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", "type": "string" } } @@ -4644,6 +5654,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -4780,6 +5803,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", @@ -6049,10 +7083,357 @@ } ] }, - "Decimal": { - "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", - "type": "string" - }, + "Decimal": { + "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", + "type": "string" + }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -6393,6 +7774,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -6411,6 +7831,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -6834,6 +8268,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -6914,6 +8441,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -7050,6 +8590,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", @@ -8206,34 +9757,324 @@ { "type": "object", "required": [ - "distribution" + "distribution" + ], + "properties": { + "distribution": { + "$ref": "#/definitions/DistributionMsg" + } + }, + "additionalProperties": false + }, + { + "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "type": "object", + "required": [ + "stargate" + ], + "properties": { + "stargate": { + "type": "object", + "required": [ + "type_url", + "value" + ], + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "$ref": "#/definitions/Binary" + } + } + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "ibc" + ], + "properties": { + "ibc": { + "$ref": "#/definitions/IbcMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "wasm" + ], + "properties": { + "wasm": { + "$ref": "#/definitions/WasmMsg" + } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": [ + "gov" + ], + "properties": { + "gov": { + "$ref": "#/definitions/GovMsg" + } + }, + "additionalProperties": false + } + ] + }, + "Decimal": { + "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", + "type": "string" + }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" ], "properties": { - "distribution": { - "$ref": "#/definitions/DistributionMsg" + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } } }, "additionalProperties": false }, { - "description": "A Stargate message encoded the same way as a protobuf [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)", + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", "type": "object", "required": [ - "stargate" + "place_limit_order" ], "properties": { - "stargate": { + "place_limit_order": { "type": "object", "required": [ - "type_url", - "value" + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" ], "properties": { - "type_url": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", "type": "string" }, - "value": { - "$ref": "#/definitions/Binary" + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" } } } @@ -8241,47 +10082,104 @@ "additionalProperties": false }, { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", "type": "object", "required": [ - "ibc" + "withdraw_filled_limit_order" ], "properties": { - "ibc": { - "$ref": "#/definitions/IbcMsg" + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", "type": "object", "required": [ - "wasm" + "cancel_limit_order" ], "properties": { - "wasm": { - "$ref": "#/definitions/WasmMsg" + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } } }, "additionalProperties": false }, { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", "type": "object", "required": [ - "gov" + "multi_hop_swap" ], "properties": { - "gov": { - "$ref": "#/definitions/GovMsg" + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } } }, "additionalProperties": false } ] }, - "Decimal": { - "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", - "type": "string" - }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -8622,6 +10520,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -8640,6 +10577,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -9063,6 +11014,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -9143,6 +11187,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -9279,6 +11336,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/execute.json b/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/execute.json index 51285e40..5df9c09c 100644 --- a/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/execute.json +++ b/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/execute.json @@ -751,6 +751,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -1078,6 +1425,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "ModuleInstantiateInfo": { "description": "Information needed to instantiate a module.", "type": "object", @@ -1136,6 +1522,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1559,6 +1959,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1639,6 +2132,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1813,6 +2319,17 @@ } ] }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/response_to_list_proposals.json b/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/response_to_list_proposals.json index e3609c7c..c9e99265 100644 --- a/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/response_to_list_proposals.json +++ b/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/response_to_list_proposals.json @@ -438,6 +438,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -778,6 +1125,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -796,6 +1182,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1219,6 +1619,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1299,6 +1792,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1435,6 +1941,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/response_to_proposal.json b/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/response_to_proposal.json index 1d4cd442..a8362cfd 100644 --- a/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/response_to_proposal.json +++ b/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/response_to_proposal.json @@ -442,6 +442,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -782,6 +1129,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -800,6 +1186,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1223,6 +1623,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1303,6 +1796,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1439,6 +1945,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/response_to_reverse_proposals.json b/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/response_to_reverse_proposals.json index e3609c7c..c9e99265 100644 --- a/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/response_to_reverse_proposals.json +++ b/contracts/subdaos/proposal/cwd-subdao-proposal-single/schema/raw/response_to_reverse_proposals.json @@ -438,6 +438,353 @@ "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, + "DenomUnit": { + "description": "Replicates the cosmos-sdk bank module DenomUnit type", + "type": "object", + "required": [ + "aliases", + "denom", + "exponent" + ], + "properties": { + "aliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "denom": { + "type": "string" + }, + "exponent": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + }, + "DepositOption": { + "type": "object", + "required": [ + "disable_swap" + ], + "properties": { + "disable_swap": { + "type": "boolean" + } + } + }, + "DexMsg": { + "oneOf": [ + { + "description": "Deposit provides liquidity to a specific trading pair by depositing tokens at a specific price into one or both sides of the pair in “a liquidity pool”", + "type": "object", + "required": [ + "deposit" + ], + "properties": { + "deposit": { + "type": "object", + "required": [ + "amounts_a", + "amounts_b", + "fees", + "options", + "receiver", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "amounts_a": { + "description": "Amounts of tokenA to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "amounts_b": { + "description": "Amounts of tokenB to deposit", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "fees": { + "description": "Fees to use for each deposit", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "options": { + "description": "Additional deposit options", + "type": "array", + "items": { + "$ref": "#/definitions/DepositOption" + } + }, + "receiver": { + "description": "The account to which PoolShares will be issued", + "type": "string" + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes to deposit at defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "Withdraw is used to redeem PoolShares for the user’s pro-rata portion of tokens within a liquidity pool. Users can withdraw from a pool at any time", + "type": "object", + "required": [ + "withdrawal" + ], + "properties": { + "withdrawal": { + "type": "object", + "required": [ + "fees", + "receiver", + "shares_to_remove", + "tick_indexes_a_to_b", + "token_a", + "token_b" + ], + "properties": { + "fees": { + "description": "Fee for the target LiquidityPools", + "type": "array", + "items": { + "type": "integer", + "format": "uint64", + "minimum": 0.0 + } + }, + "receiver": { + "description": "The account to which the tokens are credited", + "type": "string" + }, + "shares_to_remove": { + "description": "Amount of shares to remove from each pool", + "type": "array", + "items": { + "$ref": "#/definitions/Uint128" + } + }, + "tick_indexes_a_to_b": { + "description": "Tick indexes of the target LiquidityPools defined in terms of TokenA to TokenB (ie. TokenA is on the left)", + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "token_a": { + "description": "Denom for one side of the deposit", + "type": "string" + }, + "token_b": { + "description": "Denom for the opposing side of the deposit", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "PlaceLimitOrder provides the primary mechanism for trading on the Duality Dex. Limit orders can provide liquidity to the Dex (“Maker Limit Orders”) and/or can be used to trade against preexisting liquidity (“Taker Limit Orders”)", + "type": "object", + "required": [ + "place_limit_order" + ], + "properties": { + "place_limit_order": { + "type": "object", + "required": [ + "amount_in", + "order_type", + "receiver", + "tick_index_in_to_out", + "token_in", + "token_out" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to be traded", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "expiration_time": { + "description": "Expiration time for order. Only valid for GOOD_TIL_TIME limit orders", + "type": [ + "integer", + "null" + ], + "format": "uint64", + "minimum": 0.0 + }, + "max_amount_out": { + "description": "Maximum amount of TokenB can be bought. For everything except JUST_IN_TIME OrderType", + "anyOf": [ + { + "$ref": "#/definitions/Uint128" + }, + { + "type": "null" + } + ] + }, + "order_type": { + "description": "Type of limit order to be used. Must be one of: GOOD_TIL_CANCELLED, FILL_OR_KILL, IMMEDIATE_OR_CANCEL, JUST_IN_TIME, or GOOD_TIL_TIME", + "allOf": [ + { + "$ref": "#/definitions/LimitOrderType" + } + ] + }, + "receiver": { + "description": "Account to which TokenOut is credited or that will be allowed to withdraw or cancel a maker order", + "type": "string" + }, + "tick_index_in_to_out": { + "description": "Limit tick for a limit order, specified in terms of TokenIn to TokenOut", + "type": "integer", + "format": "int64" + }, + "token_in": { + "description": "Token being “sold”", + "type": "string" + }, + "token_out": { + "description": "Token being “bought”", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "WithdrawFilledLimitOrder. Once a limit order has been filled – either partially or in its entirety, it can be withdrawn at any time. Withdrawing from a limit order credits all available proceeds to the user. Withdraw can be called on a limit order multiple times as new proceeds become available", + "type": "object", + "required": [ + "withdraw_filled_limit_order" + ], + "properties": { + "withdraw_filled_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "CancelLimitOrder. Standard Taker limit orders (Good-til-cancelled & Good-til-Time) can be canceled at any time if they have not been completely filled", + "type": "object", + "required": [ + "cancel_limit_order" + ], + "properties": { + "cancel_limit_order": { + "type": "object", + "required": [ + "tranche_key" + ], + "properties": { + "tranche_key": { + "description": "TrancheKey for the target limit order", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "MultiHopSwap provides a swapping mechanism to achieve better prices by routing through a series of pools", + "type": "object", + "required": [ + "multi_hop_swap" + ], + "properties": { + "multi_hop_swap": { + "type": "object", + "required": [ + "amount_in", + "exit_limit_price", + "pick_best_route", + "receiver", + "routes" + ], + "properties": { + "amount_in": { + "description": "Amount of TokenIn to swap", + "allOf": [ + { + "$ref": "#/definitions/Uint128" + } + ] + }, + "exit_limit_price": { + "description": "Minimum price that that must be satisfied for a route to succeed", + "allOf": [ + { + "$ref": "#/definitions/PrecDec" + } + ] + }, + "pick_best_route": { + "description": "If true all routes are run and the route with the best price is used", + "type": "boolean" + }, + "receiver": { + "description": "Account to which TokenOut is credited", + "type": "string" + }, + "routes": { + "description": "Array of possible routes", + "type": "array", + "items": { + "$ref": "#/definitions/MultiHopRoute" + } + } + } + } + }, + "additionalProperties": false + } + ] + }, "DistributionMsg": { "description": "The message types of the distribution module.\n\nSee https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto", "oneOf": [ @@ -778,6 +1125,45 @@ } } }, + "LimitOrderType": { + "oneOf": [ + { + "description": "Good-til-Cancelled limit orders are hybrid maker and taker limit orders. They will attempt to trade the supplied AmountIn at the TickIndex or better. However, if they total AmountIn cannot be traded at the limit price they are remaining amount will be placed as a maker limit order. The proceeds from the taker portion are deposited into the user’s account immediately, however, the proceeds from the maker portion must be explicitly withdrawn via WithdrawLimitOrder.", + "type": "string", + "enum": [ + "GOOD_TIL_CANCELLED" + ] + }, + { + "description": "Fill-or-Kill limit orders are taker limit orders that either successfully swap 100% of the supplied AmountIn or return an error. If there is insufficient liquidity to complete the trade at or above the supplied TickIndex a Fill-or-Kill order will return an error `codespace: dex, code: 1134` (https://github.com/neutron-org/neutron/blob/main/x/dex/types/errors.go#L107 ErrGoodTilOrderWithoutExpiration).", + "type": "string", + "enum": [ + "FILL_OR_KILL" + ] + }, + { + "description": "Immediate-or-Cancel limit orders are taker orders that will swap as much as of the AmountIn as possible given available liquidity above the supplied TickIndex. Unlike Fill-or-Kill orders they will still successfully complete even if they are only able to partially trade through the AmountIn at the TickIndex or better.", + "type": "string", + "enum": [ + "IMMEDIATE_OR_CANCEL" + ] + }, + { + "description": "Just-in-Time limit orders are an advanced maker limit order that provides tradeable liquidity for exactly one block. At the end of the same block in which the Just-in-Time order was submitted the order is canceled and any untraded portion will no longer be usable as active liquidity.", + "type": "string", + "enum": [ + "JUST_IN_TIME" + ] + }, + { + "description": "Good-til-Time limit order function exactly the same as Good-til-Cancelled limit orders first trying to trade as a taker limit order and then placing any remaining amount as a maker limit order. However, the maker portion of the limit order has a specified ExpirationTime. After the ExpirationTime the order will be cancelled and can no longer be traded against. When withdrawing a Good-til-Time limit order the user will receive both the successfully traded portion of the limit order (TokenOut) as well as any remaining untraded amount (TokenIn).", + "type": "string", + "enum": [ + "GOOD_TIL_TIME" + ] + } + ] + }, "MsgExecuteContract": { "description": "MsgExecuteContract defines a call to the contract execution", "type": "object", @@ -796,6 +1182,20 @@ } } }, + "MultiHopRoute": { + "type": "object", + "required": [ + "hops" + ], + "properties": { + "hops": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "NeutronMsg": { "description": "A number of Custom messages that can call into the Neutron bindings.", "oneOf": [ @@ -1219,6 +1619,99 @@ }, "additionalProperties": false }, + { + "description": "TokenFactoryMessage Contracts can force specified `amount` of an existing factory denom that they are admin of to a `transfer_to_address` from a `transfer_from_address`.", + "type": "object", + "required": [ + "force_transfer" + ], + "properties": { + "force_transfer": { + "type": "object", + "required": [ + "amount", + "denom", + "transfer_from_address", + "transfer_to_address" + ], + "properties": { + "amount": { + "$ref": "#/definitions/Uint128" + }, + "denom": { + "type": "string" + }, + "transfer_from_address": { + "type": "string" + }, + "transfer_to_address": { + "type": "string" + } + } + } + }, + "additionalProperties": false + }, + { + "description": "TokenFactoryMessage Contracts can set a metadata for of an existing factory denom that they are admin of.", + "type": "object", + "required": [ + "set_denom_metadata" + ], + "properties": { + "set_denom_metadata": { + "type": "object", + "required": [ + "base", + "denom_units", + "description", + "display", + "name", + "symbol", + "uri", + "uri_hash" + ], + "properties": { + "base": { + "description": "*base** represents the base denom (should be the DenomUnit with exponent = 0).", + "type": "string" + }, + "denom_units": { + "description": "*denom_units** represents the list of DenomUnit's for a given coin", + "type": "array", + "items": { + "$ref": "#/definitions/DenomUnit" + } + }, + "description": { + "description": "*description** description of a token", + "type": "string" + }, + "display": { + "description": "**display** indicates the suggested denom that should be displayed in clients.", + "type": "string" + }, + "name": { + "description": "*name** defines the name of the token (eg: Cosmos Atom)", + "type": "string" + }, + "symbol": { + "description": "**symbol** is the token symbol usually shown on exchanges (eg: ATOM). This can be the same as the display.", + "type": "string" + }, + "uri": { + "description": "*uri** to a document (on or off-chain) that contains additional information. Optional.", + "type": "string" + }, + "uri_hash": { + "description": "**uri_hash** is a sha256 hash of a document pointed by URI. It's used to verify that the document didn't change. Optional.", + "type": "string" + } + } + } + }, + "additionalProperties": false + }, { "description": "AddSchedule adds new schedule with a given `name`. Until schedule is removed it will execute all `msgs` every `period` blocks. First execution is at least on `current_block + period` block. [Permissioned - DAO Only]", "type": "object", @@ -1299,6 +1792,19 @@ } }, "additionalProperties": false + }, + { + "description": "Dex messages", + "type": "object", + "required": [ + "dex" + ], + "properties": { + "dex": { + "$ref": "#/definitions/DexMsg" + } + }, + "additionalProperties": false } ] }, @@ -1435,6 +1941,17 @@ } } }, + "PrecDec": { + "type": "object", + "required": [ + "i" + ], + "properties": { + "i": { + "type": "string" + } + } + }, "ProposalExecuteMessage": { "description": "ProposalExecuteMessage defines the struct for sdk47 compatible admin proposal.", "type": "object", diff --git a/contracts/tokenomics/distribution/schema/neutron-distribution.json b/contracts/tokenomics/distribution/schema/neutron-distribution.json index 67b3bcdd..7b16716f 100644 --- a/contracts/tokenomics/distribution/schema/neutron-distribution.json +++ b/contracts/tokenomics/distribution/schema/neutron-distribution.json @@ -1,6 +1,6 @@ { "contract_name": "neutron-distribution", - "contract_version": "0.1.0", + "contract_version": "0.1.1", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", diff --git a/contracts/tokenomics/reserve/schema/neutron-reserve.json b/contracts/tokenomics/reserve/schema/neutron-reserve.json index 226c1a5f..374bce0a 100644 --- a/contracts/tokenomics/reserve/schema/neutron-reserve.json +++ b/contracts/tokenomics/reserve/schema/neutron-reserve.json @@ -1,6 +1,6 @@ { "contract_name": "neutron-reserve", - "contract_version": "0.1.1", + "contract_version": "0.1.2", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#",