From 4b68e2c9315a65d23510d2a8049c0e2f55c60aeb Mon Sep 17 00:00:00 2001 From: Unique Divine <51418232+Unique-Divine@users.noreply.github.com> Date: Fri, 24 Jun 2022 23:18:01 -0500 Subject: [PATCH] refactor: asset pair refactor and tests for testutil/testapp (#653) * feat: governance proposal type for adding oracles * govclient handler and cli command #wip * govclient handler and cli command #wip * test(pricefeed): TestAddOracleProposalFromJson * linter + cleanup * register codec for govtype * cli(pricefeed): proposal initialization with cli command #wip * debug(cli_test.go) #wip * debug cli #wip * add flag from * test(pricefeed): TestWhitelistOraclesForPairs * (pricefeed): proto and types changes * (common): Make AssetPair a proto type; write Validate methods and new utilities * refactor: update whitelist functions. (2) Create KV store for oracles and active pairs #wip * fix(pricefeed) #wip * fix,feat(pricefeed): SetMany. (2) Fix keeper_test.go * refactor: Group and refactor grpc_query price files * more fixes and quality improvements * fix: expected keepers interfaces for pricefeed * fix: get compilation and linter passing. Tests are #wip * fix,tests(pricefeed): keeper_test, params_test passing; coverage increased to 75% #wip * test(pricefeed/keeper): all keeper tests passing after refactor * fix: corrected stablecoin and pricefeed following asset pair changes * fix(common) * test(pricefeed): Short tests passing; stablecoin and perp are #wip * fix(stablecoin): abci_test.go fixed * fix(perp,vpool): refactor functions to use the proto AssetPair * fix: Change references to AssetPair.String to use AsString * fix(ibc_test.go): Use asset pair proto * test: all integration tests passing * refactor: improve variable names for codec.ProtoMarshalers and add comments * refactor: Clean up AssetPair and AssetPairs to function like sdk.Coin and sdk.Coins * refactor: move http and rest logic from gov_client.go to rest.go * finish leftover TODO items; add comments * refactor: AsString -> String using option (gogoproto.goproto_stringer_all) = false * refactor: Make common pairs for ETH and BTC. Replace UST with USDC. * feat(pricefeed): Replace GetAuthorizedAddresses with GetOraclesForPairs * (app):register proposal handler in govRouter * (cli_test.go): Verify AddOracle txResp validity and query proposal status * prepend rpc query methods with 'Query' * (cli_test.go): Move proposal to vote status by meeting min deposit * refactor: remove AssetPair.Name function * linter * refactor: use common.AssetPair proto type in the pricefeed params * refactor: Return oraclesMap from GetOraclesForPairs * add pricefeedcli.AddOracleProposalHandler to gov app.ModuleBasics * refactor: Remove AddOracleProposalWithDeposit and use govcli flag instead. 2. Use AssetPair for PostPrice * fix #wip resolve wiring and cli test flags inconsistency * feat(testutil/testapp): Utility for initializing network with configurable genesis * refactor: standardize testapp imports * fix(pricefeed): Tests passing with accepted governance vote 20 sec vote time * test(pricefeed/.../cli_test): Finish query TODOs in CmdAddOracleProposal * fix(rest.go): Proposer field was not populated during rest handler * fix: Remove CmdAddOracleProposal from pricefeed tx command * refactor: strip away governance proposal logic and wiring * refactor(testutil/testapp): Add comments and cleanup unused code * removed: remainder of add oracle proposal wiring * changes to address PR #653 comments Co-authored-by: Agent Smith --- app/ibc_test.go | 26 +- proto/common/common.proto | 17 + proto/pricefeed/genesis.proto | 8 +- proto/pricefeed/params.proto | 38 +- proto/pricefeed/query.proto | 26 +- proto/pricefeed/tx.proto | 2 +- simapp/sim_test.go | 4 +- x/common/address.go | 22 + x/common/common.go | 181 +++-- x/common/common.pb.go | 413 ++++++++++++ x/common/common_test.go | 81 ++- x/dex/client/cli/flags.go | 2 +- x/dex/client/cli/tx_create_pool.go | 4 +- x/dex/client/testutil/cli_helpers.go | 2 +- x/dex/client/testutil/cli_test.go | 61 +- x/dex/genesis_test.go | 4 +- x/dex/keeper/balances_test.go | 11 +- x/dex/keeper/grpc_query_test.go | 95 +-- x/dex/keeper/keeper_test.go | 30 +- x/dex/keeper/liquidity_test.go | 12 +- x/dex/keeper/msg_server_test.go | 116 ++-- x/dex/keeper/params_test.go | 4 +- x/dex/keeper/swap_test.go | 35 +- x/dex/simulation/operations.go | 6 +- x/dex/types/params.go | 10 +- x/epochs/abci_test.go | 8 +- x/epochs/genesis_test.go | 6 +- x/epochs/keeper/keeper_test.go | 4 +- x/incentivization/keeper/keeper_test.go | 12 +- x/incentivization/keeper/servers_test.go | 10 +- x/incentivization/module_test.go | 4 +- x/lockup/client/cli/cli_test.go | 12 +- x/lockup/keeper/keeper_test.go | 26 +- x/lockup/keeper/msg_server_test.go | 14 +- x/lockup/keeper/state_test.go | 6 +- x/lockup/module_test.go | 4 +- x/perp/client/cli/cli_test.go | 55 +- x/perp/client/cli/query.go | 2 +- x/perp/client/cli/tx.go | 2 +- x/perp/genesis_test.go | 4 +- x/perp/keeper/calc.go | 2 +- x/perp/keeper/calc_test.go | 16 +- x/perp/keeper/clearing_house_test.go | 8 +- x/perp/keeper/grpc_query.go | 2 +- x/perp/keeper/grpc_query_test.go | 6 +- x/perp/keeper/hooks.go | 4 +- x/perp/keeper/hooks_test.go | 6 +- x/perp/keeper/keeper_test.go | 6 +- x/perp/keeper/liquidate.go | 8 +- x/perp/keeper/liquidate_test.go | 18 +- x/perp/keeper/margin.go | 4 +- x/perp/keeper/margin_test.go | 82 +-- x/perp/keeper/margin_unit_test.go | 12 +- x/perp/keeper/msg_server.go | 4 +- x/perp/keeper/perp.go | 2 +- x/perp/keeper/perp_test.go | 18 +- x/perp/keeper/perp_unit_test.go | 6 +- x/perp/module_test.go | 4 +- x/perp/spec/01_concepts.md | 11 +- x/perp/types/expected_keepers.go | 12 +- x/perp/types/expected_keepers_test.go | 4 +- x/perp/types/msgs.go | 6 +- x/perp/types/state.go | 2 +- x/pricefeed/abci.go | 2 +- x/pricefeed/abci_test.go | 41 +- x/pricefeed/client/cli/cli_test.go | 311 +++++---- x/pricefeed/client/cli/query.go | 31 +- x/pricefeed/client/cli/tx.go | 11 +- x/pricefeed/genesis.go | 30 +- x/pricefeed/genesis_test.go | 114 +++- x/pricefeed/handler.go | 1 - x/pricefeed/keeper/grpc_query.go | 150 +++++ x/pricefeed/keeper/grpc_query_markets.go | 28 - x/pricefeed/keeper/grpc_query_markets_test.go | 37 - x/pricefeed/keeper/grpc_query_oracles.go | 33 - x/pricefeed/keeper/grpc_query_oracles_test.go | 47 -- x/pricefeed/keeper/grpc_query_params.go | 20 - x/pricefeed/keeper/grpc_query_params_test.go | 27 - x/pricefeed/keeper/grpc_query_price.go | 35 - x/pricefeed/keeper/grpc_query_prices.go | 30 - x/pricefeed/keeper/grpc_query_raw_prices.go | 38 -- x/pricefeed/keeper/grpc_query_test.go | 117 ++++ x/pricefeed/keeper/keeper.go | 90 ++- x/pricefeed/keeper/keeper_test.go | 212 +++--- x/pricefeed/keeper/msg_server.go | 55 ++ x/pricefeed/keeper/msg_server_post_price.go | 41 -- x/pricefeed/keeper/msg_server_test.go | 13 +- x/pricefeed/keeper/params.go | 128 ++-- x/pricefeed/keeper/params_test.go | 93 ++- x/pricefeed/keeper/store.go | 162 +++++ x/pricefeed/module.go | 3 - x/pricefeed/module_simulation.go | 8 +- x/pricefeed/types/codec.go | 5 +- x/pricefeed/types/genesis.go | 36 +- x/pricefeed/types/genesis.pb.go | 92 ++- x/pricefeed/types/genesis_test.go | 76 --- x/pricefeed/types/market.go | 124 +--- x/pricefeed/types/pair_test.go | 43 -- x/pricefeed/types/params.pb.go | 634 +++++++----------- x/pricefeed/types/query.pb.go | 310 ++++----- x/pricefeed/types/query.pb.gw.go | 144 ++-- x/pricefeed/types/store.go | 32 +- x/pricefeed/types/tx.pb.go | 76 +-- x/simulation/mod.go | 4 +- x/stablecoin/abci.go | 2 +- x/stablecoin/abci_test.go | 62 +- x/stablecoin/client/cli/cli_test.go | 59 +- x/stablecoin/genesis.go | 2 - x/stablecoin/genesis_test.go | 6 +- x/stablecoin/keeper/collateral_ratio.go | 22 +- x/stablecoin/keeper/collateral_ratio_test.go | 388 ++++++----- x/stablecoin/keeper/grpc_query_test.go | 4 +- x/stablecoin/keeper/keeper.go | 2 +- x/stablecoin/keeper/keeper_test.go | 6 +- x/stablecoin/keeper/mint_burn_stable.go | 14 +- x/stablecoin/keeper/mint_burn_stable_test.go | 210 +++--- x/stablecoin/keeper/msg_server_test.go | 4 +- x/stablecoin/keeper/params_test.go | 4 +- x/stablecoin/keeper/supply.go | 8 +- x/stablecoin/keeper/supply_test.go | 24 +- x/stablecoin/simulation/msg.go | 2 +- x/stablecoin/types/expected_keepers.go | 8 +- x/stablecoin/types/expected_keepers_test.go | 4 +- x/stablecoin/types/genesis.go | 2 +- x/stablecoin/types/params.go | 4 +- x/testutil/app/testapp.go | 68 -- x/testutil/cli/network.go | 28 +- x/testutil/cli/network_test.go | 2 +- x/testutil/cli/query.go | 9 +- x/testutil/cli/tx.go | 2 +- x/testutil/cli/util.go | 19 +- x/testutil/keeper/pricefeed.go | 1 + x/testutil/mock/perp_interfaces.go | 85 ++- x/testutil/testapp/testapp.go | 168 +++++ x/testutil/testapp/testapp_test.go | 95 +++ x/vpool/client/cli/query.go | 4 +- x/vpool/genesis_test.go | 4 +- x/vpool/keeper/keeper.go | 2 +- x/vpool/keeper/prices.go | 36 +- x/vpool/keeper/prices_test.go | 6 +- x/vpool/keeper/query_server.go | 4 +- x/vpool/types/pool.go | 7 +- x/vpool/types/pool_test.go | 8 +- 143 files changed, 3674 insertions(+), 2817 deletions(-) create mode 100644 proto/common/common.proto create mode 100644 x/common/address.go create mode 100644 x/common/common.pb.go delete mode 100644 x/pricefeed/keeper/grpc_query_markets.go delete mode 100644 x/pricefeed/keeper/grpc_query_markets_test.go delete mode 100644 x/pricefeed/keeper/grpc_query_oracles.go delete mode 100644 x/pricefeed/keeper/grpc_query_oracles_test.go delete mode 100644 x/pricefeed/keeper/grpc_query_params.go delete mode 100644 x/pricefeed/keeper/grpc_query_params_test.go delete mode 100644 x/pricefeed/keeper/grpc_query_price.go delete mode 100644 x/pricefeed/keeper/grpc_query_prices.go delete mode 100644 x/pricefeed/keeper/grpc_query_raw_prices.go create mode 100644 x/pricefeed/keeper/grpc_query_test.go delete mode 100644 x/pricefeed/keeper/msg_server_post_price.go create mode 100644 x/pricefeed/keeper/store.go delete mode 100644 x/pricefeed/types/genesis_test.go delete mode 100644 x/pricefeed/types/pair_test.go delete mode 100644 x/testutil/app/testapp.go create mode 100644 x/testutil/testapp/testapp.go create mode 100644 x/testutil/testapp/testapp_test.go diff --git a/app/ibc_test.go b/app/ibc_test.go index 6691cabdc..4b8ffd925 100644 --- a/app/ibc_test.go +++ b/app/ibc_test.go @@ -17,9 +17,10 @@ import ( "github.com/stretchr/testify/suite" "github.com/NibiruChain/nibiru/app" + "github.com/NibiruChain/nibiru/x/common" pricefeedtypes "github.com/NibiruChain/nibiru/x/pricefeed/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) /* SetupTestingApp returns the TestingApp and default genesis state used to @@ -29,23 +30,28 @@ func SetupNibiruTestingApp() ( defaultGenesis map[string]json.RawMessage, ) { // create testing app - nibiruApp, ctx := testutilapp.NewNibiruApp(true) - token0, token1 := "uatom", "unibi" + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) + + // Whitelist a pair and oracle + pair, err := common.NewAssetPair("uatom:unibi") + if err != nil { + return nil, defaultGenesis + } oracle := sample.AccAddress() nibiruApp.PricefeedKeeper.SetParams(ctx, pricefeedtypes.Params{ - Pairs: []pricefeedtypes.Pair{ - {Token0: token0, Token1: token1, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }, + Pairs: common.AssetPairs{pair}, }) - _, err := nibiruApp.PricefeedKeeper.SetPrice( - ctx, oracle, token0, token1, sdk.OneDec(), + nibiruApp.PricefeedKeeper.WhitelistOracles(ctx, []sdk.AccAddress{oracle}) + + _, err = nibiruApp.PricefeedKeeper.SetPrice( + ctx, oracle, pair.String(), sdk.OneDec(), ctx.BlockTime().Add(time.Hour), ) if err != nil { return nil, defaultGenesis } - err = nibiruApp.PricefeedKeeper.SetCurrentPrices(ctx, token0, token1) + + err = nibiruApp.PricefeedKeeper.SetCurrentPrices(ctx, pair.Token0, pair.Token1) if err != nil { return nil, defaultGenesis } diff --git a/proto/common/common.proto b/proto/common/common.proto new file mode 100644 index 000000000..d50cc0714 --- /dev/null +++ b/proto/common/common.proto @@ -0,0 +1,17 @@ +syntax = "proto3"; + +package nibiru.common; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/NibiruChain/nibiru/x/common"; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.goproto_stringer_all) = false; + +message AssetPair { + option (gogoproto.goproto_getters) = false; + string token0 = 1; + string token1 = 2; +} \ No newline at end of file diff --git a/proto/pricefeed/genesis.proto b/proto/pricefeed/genesis.proto index e2928b279..6384dc80d 100644 --- a/proto/pricefeed/genesis.proto +++ b/proto/pricefeed/genesis.proto @@ -1,5 +1,5 @@ syntax = "proto3"; -package NibiruChain.pricefeed.v1; +package nibiru.pricefeed.v1; import "gogoproto/gogo.proto"; import "pricefeed/params.proto"; @@ -10,6 +10,8 @@ option go_package = "github.com/NibiruChain/nibiru/x/pricefeed/types"; message GenesisState { // params defines all the paramaters of the module. Params params = 1 [(gogoproto.nullable) = false]; - - repeated PostedPrice posted_prices = 2 [(gogoproto.castrepeated) = "PostedPrices", (gogoproto.nullable) = false]; + repeated PostedPrice posted_prices = 2 [ + (gogoproto.castrepeated) = "PostedPrices", + (gogoproto.nullable) = false]; + repeated string genesis_oracles = 3; } diff --git a/proto/pricefeed/params.proto b/proto/pricefeed/params.proto index e2b92c483..0c38c07ab 100644 --- a/proto/pricefeed/params.proto +++ b/proto/pricefeed/params.proto @@ -1,37 +1,45 @@ syntax = "proto3"; -package NibiruChain.pricefeed.v1; +package nibiru.pricefeed.v1; import "cosmos_proto/cosmos.proto"; import "gogoproto/gogo.proto"; +import "common/common.proto"; import "google/protobuf/timestamp.proto"; option go_package = "github.com/NibiruChain/nibiru/x/pricefeed/types"; option (gogoproto.equal_all) = true; -option (gogoproto.verbose_equal_all) = true; -// Params defines the parameters for the module. +// Params defines the parameters for the x/pricefeed module. message Params { - repeated Pair pairs = 1 [(gogoproto.castrepeated) = "Pairs", (gogoproto.nullable) = false]; + // Pairs is the list of valid trading pairs for the module. + // Add new trading pairs + repeated common.AssetPair pairs = 1 [(gogoproto.nullable) = false]; } -// Pair defines an asset in the pricefeed. -message Pair { - string token0 = 1; - string token1 = 2; - repeated bytes oracles = 3 [ +// OraclesMarshaler is a codec.ProtoMarshaler for an oracles array in the +// OraclesState sdk.KVStore. +message OraclesMarshaler { + repeated bytes oracles = 1 [ (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress" ]; - bool active = 4; +} + +// ActivePairMarshaler is a codec.ProtoMarshaler for the "IsActive" status of +// a pair in the ActivePairState sdk.KVStore. +message ActivePairMarshaler { + bool is_active = 1; } // PostedPrice defines a price for an asset pair posted by a specific oracle. message PostedPrice { string pair_id = 1 [(gogoproto.customname) = "PairID"]; - bytes oracle_address = 2 [ - (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress" - ]; - string price = 3 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", (gogoproto.nullable) = false]; - google.protobuf.Timestamp expiry = 4 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; + string oracle = 2; + string price = 3 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false]; + google.protobuf.Timestamp expiry = 4 [ + (gogoproto.stdtime) = true, + (gogoproto.nullable) = false]; } // CurrentPrice defines the current price for an asset pair in the pricefeed diff --git a/proto/pricefeed/query.proto b/proto/pricefeed/query.proto index 086fbda8e..af05b7a3c 100644 --- a/proto/pricefeed/query.proto +++ b/proto/pricefeed/query.proto @@ -1,5 +1,5 @@ syntax = "proto3"; -package NibiruChain.pricefeed.v1; +package nibiru.pricefeed.v1; import "gogoproto/gogo.proto"; import "google/api/annotations.proto"; @@ -13,33 +13,33 @@ option (gogoproto.verbose_equal_all) = true; // Query defines the gRPC querier service for pricefeed module service Query { - // Params queries all parameters of the pricefeed module. - rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + // QueryParams queries all parameters of the pricefeed module. + rpc QueryParams(QueryParamsRequest) returns (QueryParamsResponse) { option (google.api.http).get = "/nibiru/pricefeed/v1beta1/params"; } - // Price queries price details for a pair - rpc Price(QueryPriceRequest) returns (QueryPriceResponse) { + // QueryPrice queries price details for a pair + rpc QueryPrice(QueryPriceRequest) returns (QueryPriceResponse) { option (google.api.http).get = "/nibiru/pricefeed/v1beta1/prices/{pair_id}"; } - // Prices queries all prices - rpc Prices(QueryPricesRequest) returns (QueryPricesResponse) { + // QueryPrices queries all prices + rpc QueryPrices(QueryPricesRequest) returns (QueryPricesResponse) { option (google.api.http).get = "/nibiru/pricefeed/v1beta1/prices"; } - // RawPrices queries all raw prices for an asset pair - rpc RawPrices(QueryRawPricesRequest) returns (QueryRawPricesResponse) { + // QueryRawPrices queries all raw prices for an asset pair + rpc QueryRawPrices(QueryRawPricesRequest) returns (QueryRawPricesResponse) { option (google.api.http).get = "/nibiru/pricefeed/v1beta1/rawprices/{pair_id}"; } - // Oracles queries all oracles for an asset pair - rpc Oracles(QueryOraclesRequest) returns (QueryOraclesResponse) { + // QueryOracles queries all oracles for an asset pair + rpc QueryOracles(QueryOraclesRequest) returns (QueryOraclesResponse) { option (google.api.http).get = "/nibiru/pricefeed/v1beta1/oracles/{pair_id}"; } - // Pairs queries all pairs - rpc Pairs(QueryPairsRequest) returns (QueryPairsResponse) { + // QueryPairs queries all pairs + rpc QueryPairs(QueryPairsRequest) returns (QueryPairsResponse) { option (google.api.http).get = "/nibiru/pricefeed/v1beta1/pairs"; } } diff --git a/proto/pricefeed/tx.proto b/proto/pricefeed/tx.proto index 62716ed83..d3ff4d76d 100644 --- a/proto/pricefeed/tx.proto +++ b/proto/pricefeed/tx.proto @@ -1,5 +1,5 @@ syntax = "proto3"; -package NibiruChain.pricefeed.v1; +package nibiru.pricefeed.v1; import "gogoproto/gogo.proto"; import "google/protobuf/timestamp.proto"; diff --git a/simapp/sim_test.go b/simapp/sim_test.go index 6fe213e2f..c0d862334 100644 --- a/simapp/sim_test.go +++ b/simapp/sim_test.go @@ -8,7 +8,7 @@ import ( simulationtypes "github.com/cosmos/cosmos-sdk/types/simulation" "github.com/cosmos/cosmos-sdk/x/simulation" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) // Profile with: @@ -52,7 +52,7 @@ func fullAppSimulation(tb testing.TB, is_testing bool) { } }() - nibiru := testutilapp.NewTestApp( /*shouldUseDefaultGenesis*/ true) + nibiru := testapp.NewNibiruApp( /*shouldUseDefaultGenesis*/ true) // Run randomized simulation: _, simParams, simErr := simulation.SimulateFromSeed( diff --git a/x/common/address.go b/x/common/address.go new file mode 100644 index 000000000..968729361 --- /dev/null +++ b/x/common/address.go @@ -0,0 +1,22 @@ +package common + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func AddrsToStrings(addrs ...sdk.AccAddress) []string { + var addrStrings []string + for _, addr := range addrs { + addrStrings = append(addrStrings, addr.String()) + } + return addrStrings +} + +func StringsToAddrs(strs ...string) []sdk.AccAddress { + var addrs []sdk.AccAddress + for _, str := range strs { + addr := sdk.MustAccAddressFromBech32(str) + addrs = append(addrs, addr) + } + return addrs +} diff --git a/x/common/common.go b/x/common/common.go index b9b926060..d4bdad4fe 100644 --- a/x/common/common.go +++ b/x/common/common.go @@ -1,83 +1,99 @@ package common import ( + "encoding/json" "fmt" "sort" "strings" + + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) var ( - GovDenom = "unibi" - CollDenom = "uust" - StableDenom = "unusd" - StakeTokenDenom = "stake" - TestTokenDenom = "test" + DenomGov = "unibi" + DenomColl = "uusdc" + DenomStable = "unusd" + DenomStakeToken = "stake" + DenomTestToken = "test" + DenomAxlBTC = "axlwbtc" + DenomAxlETH = "axlweth" + + ModuleName = "common" TreasuryPoolModuleAccount = "treasury_pool" PairSeparator = ":" - WhitelistedColl = []string{CollDenom} + WhitelistedColl = []string{DenomColl} - GovStablePool = AssetPair{Token0: GovDenom, Token1: StableDenom} - CollStablePool = AssetPair{Token0: CollDenom, Token1: StableDenom} - TestStablePool = AssetPair{Token0: TestTokenDenom, Token1: StableDenom} + PairGovStable = AssetPair{Token0: DenomGov, Token1: DenomStable} + PairCollStable = AssetPair{Token0: DenomColl, Token1: DenomStable} + PairTestStable = AssetPair{Token0: DenomTestToken, Token1: DenomStable} + PairBTCStable = AssetPair{Token0: DenomAxlBTC, Token1: DenomStable} + PairETHStable = AssetPair{Token0: DenomAxlETH, Token1: DenomStable} - ErrInvalidTokenPair = fmt.Errorf("invalid token pair") + ErrInvalidTokenPair = sdkerrors.Register(ModuleName, 1, "invalid token pair") ) -var ( - PAIR_uBTC_uNUSD = AssetPair{Token0: "uBTC", Token1: "uNUSD"} - PAIR_uETH_uNUSD = AssetPair{Token0: "uETH", Token1: "uNUSD"} -) +//----------------------------------------------------------------------------- +// AssetPair -func NewAssetPairFromStr(pair string) (AssetPair, error) { +// NewAssetPair returns a new asset pair instance if the pair is valid. +// The form, "token0:token1", is expected for 'pair'. +// Use this function to return an error instead of panicking. +func NewAssetPair(pair string) (AssetPair, error) { split := strings.Split(pair, PairSeparator) - if len(split) != 2 { - return AssetPair{}, ErrInvalidTokenPair + splitLen := len(split) + if splitLen != 2 { + if splitLen == 1 { + return AssetPair{}, sdkerrors.Wrapf(ErrInvalidTokenPair, + "pair separator missing for pair name, %v", pair) + } else { + return AssetPair{}, sdkerrors.Wrapf(ErrInvalidTokenPair, + "pair name %v must have exactly two assets, not %v", pair, splitLen) + } } if split[0] == "" || split[1] == "" { - return AssetPair{}, ErrInvalidTokenPair + return AssetPair{}, sdkerrors.Wrapf(ErrInvalidTokenPair, + "empty token identifiers are not allowed. token0: %v, token1: %v.", + split[0], split[1]) } return AssetPair{Token0: split[0], Token1: split[1]}, nil } -type AssetPair struct { - Token0 string - Token1 string -} - -// Name is the name of the pool that corresponds to the two assets on this pair. -func (pair AssetPair) Name() string { - return PoolNameFromDenoms([]string{pair.Token0, pair.Token1}) +// MustNewAssetPair returns a new asset pair. It will panic if 'pair' is invalid. +// The form, "token0:token1", is expected for 'pair'. +func MustNewAssetPair(pair string) AssetPair { + assetPair, err := NewAssetPair(pair) + if err != nil { + panic(err) + } + return assetPair } -func (pair AssetPair) PairID() string { - return pair.Name() +// SortedName is the string representation of the pair with sorted assets. +func (pair AssetPair) SortedName() string { + return SortedPairNameFromDenoms([]string{pair.Token0, pair.Token1}) } +/* String returns the string representation of the asset pair. +Note that this differs from the output of the proto-generated 'String' method. +*/ func (pair AssetPair) String() string { return fmt.Sprintf("%s%s%s", pair.Token0, PairSeparator, pair.Token1) } -func (pair AssetPair) IsProperOrder() bool { - return pair.Name() == pair.String() +func (pair AssetPair) IsSortedOrder() bool { + return pair.SortedName() == pair.String() } func (pair AssetPair) Inverse() AssetPair { return AssetPair{pair.Token1, pair.Token0} } -func (pair AssetPair) Proper() AssetPair { - if pair.IsProperOrder() { - return pair - } else { - return pair.Inverse() - } -} - func (pair AssetPair) GetBaseTokenDenom() string { return pair.Token0 } @@ -90,15 +106,15 @@ func DenomsFromPoolName(pool string) (denoms []string) { return strings.Split(pool, ":") } -// PoolNameFromDenoms returns a sorted string representing a pool of assets -func PoolNameFromDenoms(denoms []string) string { +// SortedPairNameFromDenoms returns a sorted string representing a pool of assets +func SortedPairNameFromDenoms(denoms []string) string { sort.Strings(denoms) // alphabetically sort in-place - return RawPoolNameFromDenoms(denoms) + return PairNameFromDenoms(denoms) } -// RawPoolNameFromDenoms returns a string representing a pool of assets in the +// PairNameFromDenoms returns a string representing a pool of assets in the // exact order the denoms were given as args -func RawPoolNameFromDenoms(denoms []string) string { +func PairNameFromDenoms(denoms []string) string { poolName := denoms[0] for idx, denom := range denoms { if idx != 0 { @@ -107,3 +123,82 @@ func RawPoolNameFromDenoms(denoms []string) string { } return poolName } + +// Validate performs a basic validation of the market params +func (pair AssetPair) Validate() error { + if err := sdk.ValidateDenom(pair.Token1); err != nil { + return fmt.Errorf("invalid token1 asset: %w", err) + } + if err := sdk.ValidateDenom(pair.Token0); err != nil { + return fmt.Errorf("invalid token0 asset: %w", err) + } + return nil +} + +//----------------------------------------------------------------------------- +// AssetPairs + +// AssetPairs is a set of AssetPair, one per pair. +type AssetPairs []AssetPair + +// NewAssetPairs constructs a new asset pair set. A panic will occur if one of +// the provided pair names is invalid. +func NewAssetPairs(pairStrings ...string) (pairs AssetPairs) { + for _, pairString := range pairStrings { + pairs = append(pairs, MustNewAssetPair(pairString)) + } + return pairs +} + +func (pairs AssetPairs) Contains(pair AssetPair) bool { + for _, element := range pairs { + if (element.Token0 == pair.Token0) && (element.Token1 == pair.Token1) { + return true + } + } + return false +} + +func (pairs AssetPairs) Strings() []string { + pairsStrings := []string{} + for _, pair := range pairs { + pairsStrings = append(pairsStrings, pair.String()) + } + return pairsStrings +} + +func (pairs AssetPairs) Validate() error { + seenPairs := make(map[string]bool) + for _, pair := range pairs { + pairID := SortedPairNameFromDenoms([]string{pair.Token0, pair.Token1}) + if seenPairs[pairID] { + return fmt.Errorf("duplicate pair %s", pairID) + } + if err := pair.Validate(); err != nil { + return err + } + seenPairs[pairID] = true + } + return nil +} + +// Contains checks if a token pair is contained within 'Pairs' +func (pairs AssetPairs) ContainsAtIndex(pair AssetPair) (bool, int) { + for idx, element := range pairs { + if (element.Token0 == pair.Token0) && (element.Token1 == pair.Token1) { + return true, idx + } + } + return false, -1 +} + +type assetPairsJSON AssetPairs + +// MarshalJSON implements a custom JSON marshaller for the AssetPairs type to allow +// nil AssetPairs to be encoded as empty +func (pairs AssetPairs) MarshalJSON() ([]byte, error) { + if pairs == nil { + return json.Marshal(assetPairsJSON(AssetPairs{})) + } + return json.Marshal(assetPairsJSON(pairs)) +} diff --git a/x/common/common.pb.go b/x/common/common.pb.go new file mode 100644 index 000000000..81c507814 --- /dev/null +++ b/x/common/common.pb.go @@ -0,0 +1,413 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: common/common.proto + +package common + +import ( + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type AssetPair struct { + Token0 string `protobuf:"bytes,1,opt,name=token0,proto3" json:"token0,omitempty"` + Token1 string `protobuf:"bytes,2,opt,name=token1,proto3" json:"token1,omitempty"` +} + +func (m *AssetPair) Reset() { *m = AssetPair{} } +func (*AssetPair) ProtoMessage() {} +func (*AssetPair) Descriptor() ([]byte, []int) { + return fileDescriptor_8f954d82c0b891f6, []int{0} +} +func (m *AssetPair) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AssetPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AssetPair.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *AssetPair) XXX_Merge(src proto.Message) { + xxx_messageInfo_AssetPair.Merge(m, src) +} +func (m *AssetPair) XXX_Size() int { + return m.Size() +} +func (m *AssetPair) XXX_DiscardUnknown() { + xxx_messageInfo_AssetPair.DiscardUnknown(m) +} + +var xxx_messageInfo_AssetPair proto.InternalMessageInfo + +func init() { + proto.RegisterType((*AssetPair)(nil), "nibiru.common.AssetPair") +} + +func init() { proto.RegisterFile("common/common.proto", fileDescriptor_8f954d82c0b891f6) } + +var fileDescriptor_8f954d82c0b891f6 = []byte{ + // 182 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4e, 0xce, 0xcf, 0xcd, + 0xcd, 0xcf, 0xd3, 0x87, 0x50, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0xbc, 0x79, 0x99, 0x49, + 0x99, 0x45, 0xa5, 0x7a, 0x10, 0x41, 0x29, 0x91, 0xf4, 0xfc, 0xf4, 0x7c, 0xb0, 0x8c, 0x3e, 0x88, + 0x05, 0x51, 0xa4, 0xe4, 0xc8, 0xc5, 0xe9, 0x58, 0x5c, 0x9c, 0x5a, 0x12, 0x90, 0x98, 0x59, 0x24, + 0x24, 0xc6, 0xc5, 0x56, 0x92, 0x9f, 0x9d, 0x9a, 0x67, 0x20, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x19, + 0x04, 0xe5, 0xc1, 0xc5, 0x0d, 0x25, 0x98, 0x90, 0xc4, 0x0d, 0xad, 0x58, 0x3a, 0x16, 0xc8, 0x33, + 0x38, 0xf9, 0xdc, 0x78, 0x28, 0xc7, 0xf0, 0xe0, 0xa1, 0x1c, 0xe3, 0x8a, 0x47, 0x72, 0x8c, 0x27, + 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, + 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xa5, 0x96, 0x9e, 0x59, 0x92, 0x51, 0x9a, + 0x04, 0x72, 0x8d, 0xbe, 0x1f, 0xd8, 0x61, 0xce, 0x19, 0x89, 0x99, 0x79, 0xfa, 0x10, 0x47, 0xea, + 0x57, 0x40, 0xdd, 0x9e, 0xc4, 0x06, 0x76, 0x97, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x8c, 0x94, + 0x4f, 0x6f, 0xd3, 0x00, 0x00, 0x00, +} + +func (this *AssetPair) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AssetPair) + if !ok { + that2, ok := that.(AssetPair) + if ok { + that1 = &that2 + } else { + return fmt.Errorf("that is not of type *AssetPair") + } + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AssetPair but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AssetPair but is not nil && this == nil") + } + if this.Token0 != that1.Token0 { + return fmt.Errorf("Token0 this(%v) Not Equal that(%v)", this.Token0, that1.Token0) + } + if this.Token1 != that1.Token1 { + return fmt.Errorf("Token1 this(%v) Not Equal that(%v)", this.Token1, that1.Token1) + } + return nil +} +func (this *AssetPair) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*AssetPair) + if !ok { + that2, ok := that.(AssetPair) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Token0 != that1.Token0 { + return false + } + if this.Token1 != that1.Token1 { + return false + } + return true +} +func (m *AssetPair) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AssetPair) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AssetPair) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Token1) > 0 { + i -= len(m.Token1) + copy(dAtA[i:], m.Token1) + i = encodeVarintCommon(dAtA, i, uint64(len(m.Token1))) + i-- + dAtA[i] = 0x12 + } + if len(m.Token0) > 0 { + i -= len(m.Token0) + copy(dAtA[i:], m.Token0) + i = encodeVarintCommon(dAtA, i, uint64(len(m.Token0))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintCommon(dAtA []byte, offset int, v uint64) int { + offset -= sovCommon(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *AssetPair) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Token0) + if l > 0 { + n += 1 + l + sovCommon(uint64(l)) + } + l = len(m.Token1) + if l > 0 { + n += 1 + l + sovCommon(uint64(l)) + } + return n +} + +func sovCommon(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozCommon(x uint64) (n int) { + return sovCommon(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *AssetPair) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommon + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AssetPair: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AssetPair: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Token0", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommon + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthCommon + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCommon + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Token0 = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Token1", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommon + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthCommon + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCommon + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Token1 = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCommon(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCommon + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipCommon(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCommon + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCommon + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCommon + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthCommon + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupCommon + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthCommon + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthCommon = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowCommon = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupCommon = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/common/common_test.go b/x/common/common_test.go index fa483f6e5..9a64df41c 100644 --- a/x/common/common_test.go +++ b/x/common/common_test.go @@ -40,13 +40,13 @@ func TestPairNameFromDenoms(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(tc.name, func(t *testing.T) { - outPoolName := common.PoolNameFromDenoms(tc.denoms) + outPoolName := common.SortedPairNameFromDenoms(tc.denoms) require.Equal(t, tc.poolName, outPoolName) }) } } -func TestAssetPair(t *testing.T) { +func TestAssetPair_InverseAndSort(t *testing.T) { testCases := []struct { name string pair common.AssetPair @@ -68,11 +68,13 @@ func TestAssetPair(t *testing.T) { tc := testCase t.Run(tc.name, func(t *testing.T) { if tc.proper { - require.True(t, tc.pair.IsProperOrder()) - require.Equal(t, tc.pair.Name(), tc.pair.String()) + require.Truef(t, tc.pair.IsSortedOrder(), + "pair: '%v' name: '%v'", tc.pair.String(), tc.pair.SortedName()) + require.EqualValues(t, tc.pair.SortedName(), tc.pair.String()) } else { - require.True(t, tc.pair.Inverse().IsProperOrder()) - require.Equal(t, tc.pair.Name(), tc.pair.Inverse().String()) + require.Truef(t, tc.pair.Inverse().IsSortedOrder(), + "pair: '%v' name: '%v'", tc.pair.String(), tc.pair.SortedName()) + require.EqualValues(t, tc.pair.SortedName(), tc.pair.Inverse().String()) } require.True(t, true) @@ -80,7 +82,7 @@ func TestAssetPair(t *testing.T) { } } -func TestAsset_Constructor(t *testing.T) { +func TestNewAssetPair_Constructor(t *testing.T) { tests := []struct { name string tokenPair string @@ -88,33 +90,38 @@ func TestAsset_Constructor(t *testing.T) { }{ { "only one token", - common.GovDenom, + common.DenomGov, common.ErrInvalidTokenPair, }, { "more than 2 tokens", - fmt.Sprintf("%s%s%s%s%s", common.GovDenom, common.PairSeparator, common.StableDenom, - common.PairSeparator, common.CollDenom), + fmt.Sprintf("%s%s%s%s%s", common.DenomGov, common.PairSeparator, common.DenomStable, + common.PairSeparator, common.DenomColl), common.ErrInvalidTokenPair, }, { "different separator", - fmt.Sprintf("%s%s%s", common.GovDenom, "%", common.StableDenom), + fmt.Sprintf("%s%s%s", common.DenomGov, "%", common.DenomStable), common.ErrInvalidTokenPair, }, { "correct pair", - fmt.Sprintf("%s%s%s", common.GovDenom, common.PairSeparator, common.StableDenom), + fmt.Sprintf("%s%s%s", common.DenomGov, common.PairSeparator, common.DenomStable), nil, }, + { + "empty token identifier", + fmt.Sprintf("%s%s%s", "", common.PairSeparator, "eth"), + fmt.Errorf("empty token identifiers are not allowed"), + }, } for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - _, err := common.NewAssetPairFromStr(tc.tokenPair) + _, err := common.NewAssetPair(tc.tokenPair) if tc.err != nil { - require.Equal(t, tc.err, err) + require.ErrorContains(t, err, tc.err.Error()) } else { require.NoError(t, err) } @@ -123,9 +130,53 @@ func TestAsset_Constructor(t *testing.T) { } func TestAsset_GetQuoteBaseToken(t *testing.T) { - pair, err := common.NewAssetPairFromStr("uatom:unibi") + pair, err := common.NewAssetPair("uatom:unibi") require.NoError(t, err) require.Equal(t, "uatom", pair.GetBaseTokenDenom()) require.Equal(t, "unibi", pair.GetQuoteTokenDenom()) } + +func TestAssetPair_Marshaling(t *testing.T) { + testCases := []struct { + name string + test func() + }{ + { + name: "verbose equal suite", + test: func() { + pair := common.MustNewAssetPair("abc:xyz") + matchingOther := common.MustNewAssetPair("abc:xyz") + mismatchToken1 := common.MustNewAssetPair("abc:abc") + inversePair := common.MustNewAssetPair("xyz:abc") + + require.NoError(t, (&pair).VerboseEqual(&matchingOther)) + require.True(t, (&pair).Equal(&matchingOther)) + + require.Error(t, (&pair).VerboseEqual(&inversePair)) + require.False(t, (&pair).Equal(&inversePair)) + + require.Error(t, (&pair).VerboseEqual(&mismatchToken1)) + require.True(t, !(&pair).Equal(&mismatchToken1)) + + require.Error(t, (&pair).VerboseEqual(pair.String())) + require.False(t, (&pair).Equal(&mismatchToken1)) + }, + }, + { + name: "panics suite", + test: func() { + require.Panics(t, func() { + common.MustNewAssetPair("aaa:bbb:ccc") + }) + }, + }, + } + + for _, testCase := range testCases { + tc := testCase + t.Run(tc.name, func(t *testing.T) { + tc.test() + }) + } +} diff --git a/x/dex/client/cli/flags.go b/x/dex/client/cli/flags.go index d49cccc23..32f1e6aaf 100644 --- a/x/dex/client/cli/flags.go +++ b/x/dex/client/cli/flags.go @@ -42,7 +42,7 @@ func FlagSetJoinPool() *flag.FlagSet { fs := flag.NewFlagSet("join-pool", flag.PanicOnError) fs.Uint64(FlagPoolId, 0, "The id of pool") - fs.StringArray(FlagTokensIn, []string{""}, "Amount of each denom to send into the pool (specify multiple denoms with: --tokens-in=1uust --tokens-in=1unusd)") + fs.StringArray(FlagTokensIn, []string{""}, "Amount of each denom to send into the pool (specify multiple denoms with: --tokens-in=1uusdc --tokens-in=1unusd)") return fs } diff --git a/x/dex/client/cli/tx_create_pool.go b/x/dex/client/cli/tx_create_pool.go index 2d1c9d157..559eb157d 100644 --- a/x/dex/client/cli/tx_create_pool.go +++ b/x/dex/client/cli/tx_create_pool.go @@ -32,8 +32,8 @@ $ %s tx dex create-pool --pool-file="path/to/pool.json" --from validator Where pool.json contains: { - "weights": "1unusd,1uust", - "initial-deposit": "100unusd,100uust", + "weights": "1unusd,1uusdc", + "initial-deposit": "100unusd,100uusdc", "swap-fee": "0.01", "exit-fee": "0.01" } diff --git a/x/dex/client/testutil/cli_helpers.go b/x/dex/client/testutil/cli_helpers.go index 685780a78..854f3fb70 100644 --- a/x/dex/client/testutil/cli_helpers.go +++ b/x/dex/client/testutil/cli_helpers.go @@ -18,7 +18,7 @@ import ( var commonArgs = []string{ fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation), fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock), - fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(common.GovDenom, sdk.NewInt(10))).String()), + fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(common.DenomGov, sdk.NewInt(10))).String()), } // ExecMsgCreatePool broadcast a pool creation message. diff --git a/x/dex/client/testutil/cli_test.go b/x/dex/client/testutil/cli_test.go index e0327e4e0..1c92d8408 100644 --- a/x/dex/client/testutil/cli_test.go +++ b/x/dex/client/testutil/cli_test.go @@ -15,6 +15,7 @@ import ( "github.com/stretchr/testify/suite" tmcli "github.com/tendermint/tendermint/libs/cli" + "github.com/NibiruChain/nibiru/app" "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/dex/client/cli" "github.com/NibiruChain/nibiru/x/dex/types" @@ -41,7 +42,9 @@ func (s *IntegrationTestSuite) SetupSuite() { } s.T().Log("setting up integration test suite") - s.network = testutilcli.New(s.T(), s.cfg) + + app.SetPrefixes(app.AccountAddressPrefix) + s.network = testutilcli.NewNetwork(s.T(), s.cfg) // create a new user address s.testAccount = s.NewAccount("NewAddr") @@ -50,9 +53,9 @@ func (s *IntegrationTestSuite) SetupSuite() { s.FundAccount( s.testAccount, sdk.NewCoins( - sdk.NewInt64Coin(common.StableDenom, 20000), - sdk.NewInt64Coin(common.CollDenom, 20000), - sdk.NewInt64Coin(common.GovDenom, 2e9), // for pool creation fee and more for tx fees + sdk.NewInt64Coin(common.DenomStable, 20000), + sdk.NewInt64Coin(common.DenomColl, 20000), + sdk.NewInt64Coin(common.DenomGov, 2e9), // for pool creation fee and more for tx fees ), ) } @@ -81,8 +84,8 @@ func (s IntegrationTestSuite) TestACreatePoolCmd() { }{ { name: "create pool with insufficient funds", - tokenWeights: fmt.Sprintf("1%s, 1%s", common.GovDenom, common.StableDenom), - initialDeposit: fmt.Sprintf("1000000000%s,10000000000%s", common.GovDenom, common.StableDenom), + tokenWeights: fmt.Sprintf("1%s, 1%s", common.DenomGov, common.DenomStable), + initialDeposit: fmt.Sprintf("1000000000%s,10000000000%s", common.DenomGov, common.DenomStable), swapFee: "0.003", exitFee: "0.003", extraArgs: []string{}, @@ -94,8 +97,8 @@ func (s IntegrationTestSuite) TestACreatePoolCmd() { }, { name: "create pool with invalid weights", - tokenWeights: fmt.Sprintf("0%s, 1%s", common.GovDenom, common.StableDenom), - initialDeposit: fmt.Sprintf("10000%s,10000%s", common.GovDenom, common.StableDenom), + tokenWeights: fmt.Sprintf("0%s, 1%s", common.DenomGov, common.DenomStable), + initialDeposit: fmt.Sprintf("10000%s,10000%s", common.DenomGov, common.DenomStable), swapFee: "0.003", exitFee: "0.003", extraArgs: []string{}, @@ -106,8 +109,8 @@ func (s IntegrationTestSuite) TestACreatePoolCmd() { }, { name: "create pool with deposit not matching weights", - tokenWeights: "1unibi, 1uust", - initialDeposit: "1000foo,10000uust", + tokenWeights: "1unibi, 1uusdc", + initialDeposit: "1000foo,10000uusdc", swapFee: "0.003", exitFee: "0.003", extraArgs: []string{}, @@ -118,8 +121,8 @@ func (s IntegrationTestSuite) TestACreatePoolCmd() { }, { name: "create pool with sufficient funds", - tokenWeights: "1unibi,1uust", - initialDeposit: "100unibi,100uust", + tokenWeights: "1unibi,1uusdc", + initialDeposit: "100unibi,100uusdc", swapFee: "0.01", exitFee: "0.01", extraArgs: []string{}, @@ -168,8 +171,8 @@ func (s IntegrationTestSuite) TestBNewJoinPoolCmd() { s.T(), val.ClientCtx, /*owner-*/ val.Address, - /*tokenWeights=*/ "5unibi,5uust", - /*initialDeposit=*/ "100unibi,100uust", + /*tokenWeights=*/ "5unibi,5uusdc", + /*initialDeposit=*/ "100unibi,100uusdc", /*swapFee=*/ "0.01", /*exitFee=*/ "0.01", ) @@ -186,7 +189,7 @@ func (s IntegrationTestSuite) TestBNewJoinPoolCmd() { { name: "join pool with insufficient balance", poolId: 1, - tokensIn: "1000000000unibi,10000000000uust", + tokensIn: "1000000000unibi,10000000000uusdc", expectErr: false, respType: &sdk.TxResponse{}, expectedCode: 5, // bankKeeper code for insufficient funds @@ -194,7 +197,7 @@ func (s IntegrationTestSuite) TestBNewJoinPoolCmd() { { name: "join pool with sufficient balance", poolId: 1, - tokensIn: "100unibi,100uust", + tokensIn: "100unibi,100uusdc", expectErr: false, respType: &sdk.TxResponse{}, expectedCode: 0, @@ -272,7 +275,7 @@ func (s IntegrationTestSuite) TestCNewExitPoolCmd() { respType: &sdk.TxResponse{}, expectedCode: 0, expectedunibi: sdk.NewInt(100 - 10 - 1), // Received unibi minus 10unibi tx fee minus 1 exit pool fee - expectedOtherToken: sdk.NewInt(100 - 1), // Received uust minus 1 exit pool fee + expectedOtherToken: sdk.NewInt(100 - 1), // Received uusdc minus 1 exit pool fee }, } @@ -308,8 +311,8 @@ func (s IntegrationTestSuite) TestCNewExitPoolCmd() { fmt.Println(finalBalance) s.Require().Equal( - originalBalance.Balances.AmountOf("uust").Add(tc.expectedOtherToken), - finalBalance.Balances.AmountOf("uust"), + originalBalance.Balances.AmountOf("uusdc").Add(tc.expectedOtherToken), + finalBalance.Balances.AmountOf("uusdc"), ) s.Require().Equal( originalBalance.Balances.AmountOf("unibi").Add(tc.expectedunibi), @@ -372,14 +375,14 @@ func (s *IntegrationTestSuite) TestESwapAssets() { name: "zero pool id", poolId: 0, tokenIn: "50unibi", - tokenOutDenom: "uust", + tokenOutDenom: "uusdc", expectErr: true, }, { name: "invalid token in", poolId: 1, tokenIn: "0unibi", - tokenOutDenom: "uust", + tokenOutDenom: "uusdc", expectErr: true, }, { @@ -393,7 +396,7 @@ func (s *IntegrationTestSuite) TestESwapAssets() { name: "pool not found", poolId: 1000000, tokenIn: "50unibi", - tokenOutDenom: "uust", + tokenOutDenom: "uusdc", respType: &sdk.TxResponse{}, expectedCode: types.ErrPoolNotFound.ABCICode(), expectErr: false, @@ -402,7 +405,7 @@ func (s *IntegrationTestSuite) TestESwapAssets() { name: "token in denom not found", poolId: 1, tokenIn: "50foo", - tokenOutDenom: "uust", + tokenOutDenom: "uusdc", respType: &sdk.TxResponse{}, expectedCode: types.ErrTokenDenomNotFound.ABCICode(), expectErr: false, @@ -420,7 +423,7 @@ func (s *IntegrationTestSuite) TestESwapAssets() { name: "successful swap", poolId: 1, tokenIn: "50unibi", - tokenOutDenom: "uust", + tokenOutDenom: "uusdc", respType: &sdk.TxResponse{}, expectedCode: 0, expectErr: false, @@ -447,12 +450,14 @@ func (s *IntegrationTestSuite) TestESwapAssets() { } func TestIntegrationTestSuite(t *testing.T) { - cfg := testutilcli.DefaultConfig() + encodingConfig := app.MakeTestEncodingConfig() + defaultAppGenesis := app.NewDefaultGenesisState(encodingConfig.Marshaler) + cfg := testutilcli.BuildNetworkConfig(defaultAppGenesis) cfg.UpdateStartingToken( sdk.NewCoins( - sdk.NewInt64Coin(common.StableDenom, 20000), - sdk.NewInt64Coin(common.CollDenom, 20000), - sdk.NewInt64Coin(common.GovDenom, 2e9), // for pool creation fee and more for tx fees + sdk.NewInt64Coin(common.DenomStable, 20000), + sdk.NewInt64Coin(common.DenomColl, 20000), + sdk.NewInt64Coin(common.DenomGov, 2e9), // for pool creation fee and more for tx fees ), ) suite.Run(t, &IntegrationTestSuite{cfg: cfg}) diff --git a/x/dex/genesis_test.go b/x/dex/genesis_test.go index fd0761414..f78145bfc 100644 --- a/x/dex/genesis_test.go +++ b/x/dex/genesis_test.go @@ -7,8 +7,8 @@ import ( "github.com/NibiruChain/nibiru/x/dex" "github.com/NibiruChain/nibiru/x/dex/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/nullify" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestGenesis(t *testing.T) { @@ -16,7 +16,7 @@ func TestGenesis(t *testing.T) { Params: types.DefaultParams(), } - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) dex.InitGenesis(ctx, app.DexKeeper, genesisState) got := dex.ExportGenesis(ctx, app.DexKeeper) require.NotNil(t, got) diff --git a/x/dex/keeper/balances_test.go b/x/dex/keeper/balances_test.go index 0a51ccead..45bcf0199 100644 --- a/x/dex/keeper/balances_test.go +++ b/x/dex/keeper/balances_test.go @@ -8,8 +8,9 @@ import ( sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/stretchr/testify/require" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestCheckBalances(t *testing.T) { @@ -27,11 +28,11 @@ func TestCheckBalances(t *testing.T) { name: "has enough funds", userInitialFunds: sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), coinsToSpend: sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), expectedError: nil, }, @@ -42,7 +43,7 @@ func TestCheckBalances(t *testing.T) { ), coinsToSpend: sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), expectedError: sdkerrors.ErrInsufficientFunds, }, @@ -51,7 +52,7 @@ func TestCheckBalances(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) // fund user account sender := sample.AccAddress() diff --git a/x/dex/keeper/grpc_query_test.go b/x/dex/keeper/grpc_query_test.go index f2f94e8d7..25ac93e91 100644 --- a/x/dex/keeper/grpc_query_test.go +++ b/x/dex/keeper/grpc_query_test.go @@ -8,15 +8,16 @@ import ( "github.com/cosmos/cosmos-sdk/types/query" "github.com/stretchr/testify/require" + "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/dex/keeper" "github.com/NibiruChain/nibiru/x/dex/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/mock" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestParamsQuery(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) params := types.DefaultParams() app.DexKeeper.SetParams(ctx, params) @@ -61,7 +62,7 @@ func TestQueryPoolHappyPath(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) app.DexKeeper.SetPool(ctx, tc.existingPool) queryServer := keeper.NewQuerier(app.DexKeeper) @@ -87,7 +88,7 @@ func TestQueryPoolFail(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) queryServer := keeper.NewQuerier(app.DexKeeper) resp, err := queryServer.Pool(sdk.WrapSDKContext(ctx), nil) require.Error(t, err) @@ -204,7 +205,7 @@ func TestQueryPools(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) for _, existingPool := range tc.existingPools { app.DexKeeper.SetPool(ctx, existingPool) } @@ -241,7 +242,7 @@ func TestQueryNumPools(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -255,22 +256,22 @@ func TestQueryNumPools(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("uust", 100), + sdk.NewInt64Coin(common.DenomColl, 100), ), /*shares=*/ 100, ), mock.DexPool( /*poolId=*/ 2, /*assets=*/ sdk.NewCoins( - sdk.NewInt64Coin("uust", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomColl, 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), mock.DexPool( /*poolId=*/ 3, /*assets=*/ sdk.NewCoins( - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), sdk.NewInt64Coin("unibi", 100), ), /*shares=*/ 100, @@ -283,7 +284,7 @@ func TestQueryNumPools(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) sender := sample.AccAddress() // need funds to create pools require.NoError(t, simapp.FundAccount( @@ -291,9 +292,9 @@ func TestQueryNumPools(t *testing.T) { ctx, sender, sdk.NewCoins( - sdk.NewInt64Coin("unibi", 1e18), - sdk.NewInt64Coin("unusd", 1e18), - sdk.NewInt64Coin("uust", 1e18), + sdk.NewInt64Coin(common.DenomGov, 1e18), + sdk.NewInt64Coin(common.DenomStable, 1e18), + sdk.NewInt64Coin(common.DenomColl, 1e18), ), )) @@ -357,7 +358,7 @@ func TestQueryPoolParams(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) app.DexKeeper.SetPool(ctx, tc.existingPool) queryServer := keeper.NewQuerier(app.DexKeeper) @@ -383,7 +384,7 @@ func TestQueryTotalShares(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -394,7 +395,7 @@ func TestQueryTotalShares(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) app.DexKeeper.SetPool(ctx, tc.existingPool) @@ -426,11 +427,11 @@ func TestQuerySpotPrice(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), - tokenInDenom: "unusd", + tokenInDenom: common.DenomStable, tokenOutDenom: "unibi", expectedPrice: sdk.MustNewDecFromStr("1"), }, @@ -440,11 +441,11 @@ func TestQuerySpotPrice(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 200), + sdk.NewInt64Coin(common.DenomStable, 200), ), /*shares=*/ 100, ), - tokenInDenom: "unusd", + tokenInDenom: common.DenomStable, tokenOutDenom: "unibi", expectedPrice: sdk.MustNewDecFromStr("2"), }, @@ -454,12 +455,12 @@ func TestQuerySpotPrice(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 200), + sdk.NewInt64Coin(common.DenomStable, 200), ), /*shares=*/ 100, ), tokenInDenom: "unibi", - tokenOutDenom: "unusd", + tokenOutDenom: common.DenomStable, expectedPrice: sdk.MustNewDecFromStr("0.5"), }, } @@ -467,7 +468,7 @@ func TestQuerySpotPrice(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) app.DexKeeper.SetPool(ctx, tc.existingPool) @@ -501,11 +502,11 @@ func TestQueryEstimateSwapExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), - tokenIn: sdk.NewInt64Coin("unusd", 100), + tokenIn: sdk.NewInt64Coin(common.DenomStable, 100), tokenOutDenom: "unibi", expectedTokenOut: sdk.NewInt64Coin("unibi", 50), }, @@ -515,21 +516,21 @@ func TestQueryEstimateSwapExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 34844867), - sdk.NewInt64Coin("unusd", 4684496849), + sdk.NewInt64Coin(common.DenomStable, 4684496849), ), /*shares=*/ 100, ), tokenIn: sdk.NewInt64Coin("unibi", 586848), - tokenOutDenom: "unusd", + tokenOutDenom: common.DenomStable, // https://www.wolframalpha.com/input?i=4684496849+-+%2834844867+*+4684496849+%2F+%2834844867%2B586848%29+%29 - expectedTokenOut: sdk.NewInt64Coin("unusd", 77588330), + expectedTokenOut: sdk.NewInt64Coin(common.DenomStable, 77588330), }, } for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) app.DexKeeper.SetPool(ctx, tc.existingPool) queryServer := keeper.NewQuerier(app.DexKeeper) @@ -562,14 +563,14 @@ func TestQueryEstimateSwapExactAmountOut(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), tokenOut: sdk.NewInt64Coin("unibi", 50), - tokenInDenom: "unusd", + tokenInDenom: common.DenomStable, // there's a swap fee that we take the ceiling of to round int - expectedTokenIn: sdk.NewInt64Coin("unusd", 101), + expectedTokenIn: sdk.NewInt64Coin(common.DenomStable, 101), }, { name: "complex swap", @@ -577,11 +578,11 @@ func TestQueryEstimateSwapExactAmountOut(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 34844867), - sdk.NewInt64Coin("unusd", 4684496849), + sdk.NewInt64Coin(common.DenomStable, 4684496849), ), /*shares=*/ 100, ), - tokenOut: sdk.NewInt64Coin("unusd", 77588330), + tokenOut: sdk.NewInt64Coin(common.DenomStable, 77588330), tokenInDenom: "unibi", // https://www.wolframalpha.com/input?i=4684496849+-+%2834844867+*+4684496849+%2F+%2834844867%2B586848%29+%29 expectedTokenIn: sdk.NewInt64Coin("unibi", 586848), @@ -591,7 +592,7 @@ func TestQueryEstimateSwapExactAmountOut(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) app.DexKeeper.SetPool(ctx, tc.existingPool) queryServer := keeper.NewQuerier(app.DexKeeper) @@ -624,13 +625,13 @@ func TestQueryEstimateJoinExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), tokensIn: sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), expectedPoolSharesOut: sdk.NewIntFromUint64(100), expectedRemCoins: sdk.NewCoins(), @@ -641,17 +642,17 @@ func TestQueryEstimateJoinExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), tokensIn: sdk.NewCoins( sdk.NewInt64Coin("unibi", 50), - sdk.NewInt64Coin("unusd", 75), + sdk.NewInt64Coin(common.DenomStable, 75), ), expectedPoolSharesOut: sdk.NewIntFromUint64(50), expectedRemCoins: sdk.NewCoins( - sdk.NewInt64Coin("unusd", 25), + sdk.NewInt64Coin(common.DenomStable, 25), ), }, } @@ -659,7 +660,7 @@ func TestQueryEstimateJoinExactAmountIn(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) app.DexKeeper.SetPool(ctx, tc.existingPool) queryServer := keeper.NewQuerier(app.DexKeeper) @@ -691,7 +692,7 @@ func TestQueryEstimateExitExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -699,7 +700,7 @@ func TestQueryEstimateExitExactAmountIn(t *testing.T) { // exit fee leaves some tokens in pool expectedTokensOut: sdk.NewCoins( sdk.NewInt64Coin("unibi", 99), - sdk.NewInt64Coin("unusd", 99), + sdk.NewInt64Coin(common.DenomStable, 99), ), }, { @@ -708,7 +709,7 @@ func TestQueryEstimateExitExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -716,7 +717,7 @@ func TestQueryEstimateExitExactAmountIn(t *testing.T) { // exit fee leaves some tokens in pool expectedTokensOut: sdk.NewCoins( sdk.NewInt64Coin("unibi", 49), - sdk.NewInt64Coin("unusd", 49), + sdk.NewInt64Coin(common.DenomStable, 49), ), }, } @@ -724,7 +725,7 @@ func TestQueryEstimateExitExactAmountIn(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) app.DexKeeper.SetPool(ctx, tc.existingPool) queryServer := keeper.NewQuerier(app.DexKeeper) diff --git a/x/dex/keeper/keeper_test.go b/x/dex/keeper/keeper_test.go index 30495ddda..d62ce9101 100644 --- a/x/dex/keeper/keeper_test.go +++ b/x/dex/keeper/keeper_test.go @@ -10,13 +10,13 @@ import ( "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/dex/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/mock" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestGetAndSetNextPoolNumber(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) // Write to store app.DexKeeper.SetNextPoolNumber(ctx, 150) @@ -28,7 +28,7 @@ func TestGetAndSetNextPoolNumber(t *testing.T) { } func TestGetNextPoolNumberAndIncrement(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) // Write a pool number app.DexKeeper.SetNextPoolNumber(ctx, 200) @@ -43,7 +43,7 @@ func TestGetNextPoolNumberAndIncrement(t *testing.T) { } func TestSetAndFetchPool(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) pool := types.Pool{ Id: 150, @@ -57,7 +57,7 @@ func TestSetAndFetchPool(t *testing.T) { Weight: sdk.NewInt(1), }, { - Token: sdk.NewCoin(common.StakeTokenDenom, sdk.NewInt(1000)), + Token: sdk.NewCoin(common.DenomStakeToken, sdk.NewInt(1000)), Weight: sdk.NewInt(1), }, }, @@ -150,7 +150,7 @@ func TestFetchPoolFromPair(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) app.DexKeeper.SetPool(ctx, types.Pool{ Id: 1, @@ -208,9 +208,9 @@ func TestFetchPoolFromPair(t *testing.T) { } func TestNewPool(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) - poolCreationFeeCoin := sdk.NewInt64Coin(common.GovDenom, 1000_000_000) + poolCreationFeeCoin := sdk.NewInt64Coin(common.DenomGov, 1000_000_000) app.DexKeeper.SetParams(ctx, types.NewParams( /*startingPoolNumber=*/ 1, /*poolCreationFee=*/ sdk.NewCoins(poolCreationFeeCoin), @@ -275,11 +275,11 @@ func TestNewPool(t *testing.T) { } func TestNewPoolNotEnoughFunds(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) app.DexKeeper.SetParams(ctx, types.NewParams( /*startingPoolNumber=*/ 1, - /*poolCreationFee=*/ sdk.NewCoins(sdk.NewInt64Coin(common.GovDenom, 1000_000_000)), + /*poolCreationFee=*/ sdk.NewCoins(sdk.NewInt64Coin(common.DenomGov, 1000_000_000)), /*whitelistedAssets*/ []string{}, )) @@ -315,7 +315,7 @@ func TestNewPoolNotEnoughFunds(t *testing.T) { } func TestNewPoolTooLittleAssets(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) userAddr, err := sdk.AccAddressFromBech32(sample.AccAddress().String()) require.NoError(t, err) @@ -335,7 +335,7 @@ func TestNewPoolTooLittleAssets(t *testing.T) { } func TestKeeperNewPoolNotWhitelistedAssets(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) userAddr, err := sdk.AccAddressFromBech32(sample.AccAddress().String()) require.NoError(t, err) @@ -359,7 +359,7 @@ func TestKeeperNewPoolNotWhitelistedAssets(t *testing.T) { } func TestNewPoolTooManyAssets(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) userAddr, err := sdk.AccAddressFromBech32(sample.AccAddress().String()) require.NoError(t, err) @@ -514,7 +514,7 @@ func TestJoinPool(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) poolAddr := sample.AccAddress() tc.initialPool.Address = poolAddr.String() @@ -626,7 +626,7 @@ func TestExitPool(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) poolAddr := sample.AccAddress() tc.initialPool.Address = poolAddr.String() diff --git a/x/dex/keeper/liquidity_test.go b/x/dex/keeper/liquidity_test.go index e9866d5e4..52258202b 100644 --- a/x/dex/keeper/liquidity_test.go +++ b/x/dex/keeper/liquidity_test.go @@ -6,11 +6,11 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/stretchr/testify/require" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestGetSetDenomLiquidity(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) // Write to store app.DexKeeper.SetDenomLiquidity(ctx, "nibi", sdk.NewInt(1000)) @@ -22,7 +22,7 @@ func TestGetSetDenomLiquidity(t *testing.T) { } func TestGetTotalLiquidity(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) // Write to store app.DexKeeper.SetDenomLiquidity(ctx, "atom", sdk.NewInt(123)) @@ -40,7 +40,7 @@ func TestGetTotalLiquidity(t *testing.T) { } func TestSetTotalLiquidity(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) // Write to store app.DexKeeper.SetTotalLiquidity(ctx, sdk.NewCoins( @@ -56,7 +56,7 @@ func TestSetTotalLiquidity(t *testing.T) { } func TestRecordTotalLiquidityIncrease(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) // Write to store app.DexKeeper.SetTotalLiquidity(ctx, sdk.NewCoins( @@ -73,7 +73,7 @@ func TestRecordTotalLiquidityIncrease(t *testing.T) { } func TestRecordTotalLiquidityDecrease(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) // Write to store app.DexKeeper.SetTotalLiquidity(ctx, sdk.NewCoins( diff --git a/x/dex/keeper/msg_server_test.go b/x/dex/keeper/msg_server_test.go index a564d7b49..1c638039a 100644 --- a/x/dex/keeper/msg_server_test.go +++ b/x/dex/keeper/msg_server_test.go @@ -13,10 +13,10 @@ import ( "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/dex/keeper" "github.com/NibiruChain/nibiru/x/dex/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/events" "github.com/NibiruChain/nibiru/x/testutil/mock" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestCreatePool(t *testing.T) { @@ -65,7 +65,7 @@ func TestCreatePool(t *testing.T) { poolParams: types.PoolParams{}, poolAssets: []types.PoolAsset{ { - Token: sdk.NewInt64Coin(common.CollDenom, 1), + Token: sdk.NewInt64Coin(common.DenomColl, 1), Weight: sdk.OneInt(), }, { @@ -84,7 +84,7 @@ func TestCreatePool(t *testing.T) { Weight: sdk.OneInt(), }, { - Token: sdk.NewInt64Coin(common.CollDenom, 1), + Token: sdk.NewInt64Coin(common.DenomColl, 1), Weight: sdk.OneInt(), }, }, @@ -95,11 +95,11 @@ func TestCreatePool(t *testing.T) { poolParams: types.PoolParams{}, poolAssets: []types.PoolAsset{ { - Token: sdk.NewInt64Coin(common.CollDenom, 1), + Token: sdk.NewInt64Coin(common.DenomColl, 1), Weight: sdk.OneInt(), }, { - Token: sdk.NewInt64Coin(common.StableDenom, 1), + Token: sdk.NewInt64Coin(common.DenomStable, 1), Weight: sdk.OneInt(), }, }, @@ -115,11 +115,11 @@ func TestCreatePool(t *testing.T) { poolParams: types.PoolParams{}, poolAssets: []types.PoolAsset{ { - Token: sdk.NewInt64Coin(common.GovDenom, 1), + Token: sdk.NewInt64Coin(common.DenomGov, 1), Weight: sdk.OneInt(), }, { - Token: sdk.NewInt64Coin(common.CollDenom, 1), + Token: sdk.NewInt64Coin(common.DenomColl, 1), Weight: sdk.OneInt(), }, }, @@ -133,18 +133,18 @@ func TestCreatePool(t *testing.T) { poolParams: types.PoolParams{}, poolAssets: []types.PoolAsset{ { - Token: sdk.NewInt64Coin(common.StableDenom, 1), + Token: sdk.NewInt64Coin(common.DenomStable, 1), Weight: sdk.OneInt(), }, { - Token: sdk.NewInt64Coin(common.CollDenom, 1), + Token: sdk.NewInt64Coin(common.DenomColl, 1), Weight: sdk.OneInt(), }, }, senderInitialFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.GovDenom, 1e9), - sdk.NewInt64Coin(common.StableDenom, 1), - sdk.NewInt64Coin(common.CollDenom, 1), + sdk.NewInt64Coin(common.DenomGov, 1e9), + sdk.NewInt64Coin(common.DenomStable, 1), + sdk.NewInt64Coin(common.DenomColl, 1), ), expectedErr: nil, }, @@ -153,7 +153,7 @@ func TestCreatePool(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) msgServer := keeper.NewMsgServerImpl(app.DexKeeper) if tc.creatorAddr == nil { @@ -203,18 +203,18 @@ func TestMsgServerJoinPool(t *testing.T) { name: "join with all assets", joinerInitialFunds: sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), initialPool: mock.DexPool( /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100), tokensIn: sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), expectedNumSharesOut: sdk.NewInt64Coin(shareDenom, 100), expectedRemCoins: sdk.NewCoins(), @@ -223,7 +223,7 @@ func TestMsgServerJoinPool(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 200), - sdk.NewInt64Coin("unusd", 200), + sdk.NewInt64Coin(common.DenomStable, 200), ), /*shares=*/ 200), }, @@ -231,31 +231,31 @@ func TestMsgServerJoinPool(t *testing.T) { name: "join with some assets, none remaining", joinerInitialFunds: sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), initialPool: mock.DexPool( /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100), tokensIn: sdk.NewCoins( sdk.NewInt64Coin("unibi", 50), - sdk.NewInt64Coin("unusd", 50), + sdk.NewInt64Coin(common.DenomStable, 50), ), expectedNumSharesOut: sdk.NewInt64Coin(shareDenom, 50), expectedRemCoins: sdk.NewCoins(), expectedJoinerFinalFunds: sdk.NewCoins( sdk.NewInt64Coin(shareDenom, 50), sdk.NewInt64Coin("unibi", 50), - sdk.NewInt64Coin("unusd", 50), + sdk.NewInt64Coin(common.DenomStable, 50), ), expectedFinalPool: mock.DexPool( /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 150), - sdk.NewInt64Coin("unusd", 150), + sdk.NewInt64Coin(common.DenomStable, 150), ), /*shares=*/ 150), }, @@ -263,33 +263,33 @@ func TestMsgServerJoinPool(t *testing.T) { name: "join with some assets, some remaining", joinerInitialFunds: sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), initialPool: mock.DexPool( /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100), tokensIn: sdk.NewCoins( sdk.NewInt64Coin("unibi", 50), - sdk.NewInt64Coin("unusd", 75), + sdk.NewInt64Coin(common.DenomStable, 75), ), expectedNumSharesOut: sdk.NewInt64Coin(shareDenom, 50), expectedRemCoins: sdk.NewCoins( - sdk.NewInt64Coin("unusd", 25), + sdk.NewInt64Coin(common.DenomStable, 25), ), expectedJoinerFinalFunds: sdk.NewCoins( sdk.NewInt64Coin(shareDenom, 50), sdk.NewInt64Coin("unibi", 50), - sdk.NewInt64Coin("unusd", 50), + sdk.NewInt64Coin(common.DenomStable, 50), ), expectedFinalPool: mock.DexPool( /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 150), - sdk.NewInt64Coin("unusd", 150), + sdk.NewInt64Coin(common.DenomStable, 150), ), /*shares=*/ 150), }, @@ -298,7 +298,7 @@ func TestMsgServerJoinPool(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) poolAddr := sample.AccAddress() tc.initialPool.Address = poolAddr.String() @@ -349,35 +349,35 @@ func TestMsgServerExitPool(t *testing.T) { name: "exit all pool shares", joinerInitialFunds: sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), sdk.NewInt64Coin(shareDenom, 100), ), initialPoolFunds: sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), initialPool: mock.DexPool( /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), poolSharesIn: sdk.NewInt64Coin(shareDenom, 100), expectedTokensOut: sdk.NewCoins( sdk.NewInt64Coin("unibi", 99), - sdk.NewInt64Coin("unusd", 99), + sdk.NewInt64Coin(common.DenomStable, 99), ), expectedJoinerFinalFunds: sdk.NewCoins( sdk.NewInt64Coin("unibi", 199), - sdk.NewInt64Coin("unusd", 199), + sdk.NewInt64Coin(common.DenomStable, 199), ), expectedFinalPool: mock.DexPool( /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 1), - sdk.NewInt64Coin("unusd", 1), + sdk.NewInt64Coin(common.DenomStable, 1), ), /*shares=*/ 0, ), @@ -386,36 +386,36 @@ func TestMsgServerExitPool(t *testing.T) { name: "exit half pool shares", joinerInitialFunds: sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), sdk.NewInt64Coin(shareDenom, 100), ), initialPoolFunds: sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), initialPool: mock.DexPool( /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), poolSharesIn: sdk.NewInt64Coin(shareDenom, 50), expectedTokensOut: sdk.NewCoins( sdk.NewInt64Coin("unibi", 49), - sdk.NewInt64Coin("unusd", 49), + sdk.NewInt64Coin(common.DenomStable, 49), ), expectedJoinerFinalFunds: sdk.NewCoins( sdk.NewInt64Coin("unibi", 149), - sdk.NewInt64Coin("unusd", 149), + sdk.NewInt64Coin(common.DenomStable, 149), sdk.NewInt64Coin(shareDenom, 50), ), expectedFinalPool: mock.DexPool( /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 51), - sdk.NewInt64Coin("unusd", 51), + sdk.NewInt64Coin(common.DenomStable, 51), ), /*shares=*/ 50, ), @@ -425,7 +425,7 @@ func TestMsgServerExitPool(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) poolAddr := sample.AccAddress() tc.initialPool.Address = poolAddr.String() @@ -490,21 +490,21 @@ func TestMsgServerSwapAssets(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), tokenIn: sdk.NewInt64Coin("unibi", 100), - tokenOutDenom: "unusd", - expectedTokenOut: sdk.NewInt64Coin("unusd", 50), + tokenOutDenom: common.DenomStable, + expectedTokenOut: sdk.NewInt64Coin(common.DenomStable, 50), expectedUserFinalFunds: sdk.NewCoins( - sdk.NewInt64Coin("unusd", 50), + sdk.NewInt64Coin(common.DenomStable, 50), ), expectedFinalPool: mock.DexPool( /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 200), - sdk.NewInt64Coin("unusd", 50), + sdk.NewInt64Coin(common.DenomStable, 50), ), /*shares=*/ 100, ), @@ -519,12 +519,12 @@ func TestMsgServerSwapAssets(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), tokenIn: sdk.NewInt64Coin("unibi", 100), - tokenOutDenom: "unusd", + tokenOutDenom: common.DenomStable, expectedUserFinalFunds: sdk.NewCoins( sdk.NewInt64Coin("unibi", 1), ), @@ -532,7 +532,7 @@ func TestMsgServerSwapAssets(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -547,12 +547,12 @@ func TestMsgServerSwapAssets(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), tokenIn: sdk.NewInt64Coin("foo", 100), - tokenOutDenom: "unusd", + tokenOutDenom: common.DenomStable, expectedUserFinalFunds: sdk.NewCoins( sdk.NewInt64Coin("foo", 100), ), @@ -560,7 +560,7 @@ func TestMsgServerSwapAssets(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -575,7 +575,7 @@ func TestMsgServerSwapAssets(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -588,7 +588,7 @@ func TestMsgServerSwapAssets(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -603,7 +603,7 @@ func TestMsgServerSwapAssets(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -616,7 +616,7 @@ func TestMsgServerSwapAssets(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -627,7 +627,7 @@ func TestMsgServerSwapAssets(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) msgServer := keeper.NewMsgServerImpl(app.DexKeeper) // fund pool account diff --git a/x/dex/keeper/params_test.go b/x/dex/keeper/params_test.go index 68499478a..42172fabb 100644 --- a/x/dex/keeper/params_test.go +++ b/x/dex/keeper/params_test.go @@ -6,11 +6,11 @@ import ( "github.com/stretchr/testify/require" "github.com/NibiruChain/nibiru/x/dex/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestGetParams(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) params := types.DefaultParams() app.DexKeeper.SetParams(ctx, params) diff --git a/x/dex/keeper/swap_test.go b/x/dex/keeper/swap_test.go index 6cfcf4381..fff7cc40e 100644 --- a/x/dex/keeper/swap_test.go +++ b/x/dex/keeper/swap_test.go @@ -8,10 +8,11 @@ import ( sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/stretchr/testify/require" + "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/dex/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/mock" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestSwapExactAmountIn(t *testing.T) { @@ -39,21 +40,21 @@ func TestSwapExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), tokenIn: sdk.NewInt64Coin("unibi", 100), - tokenOutDenom: "unusd", - expectedTokenOut: sdk.NewInt64Coin("unusd", 50), + tokenOutDenom: common.DenomStable, + expectedTokenOut: sdk.NewInt64Coin(common.DenomStable, 50), expectedUserFinalFunds: sdk.NewCoins( - sdk.NewInt64Coin("unusd", 50), + sdk.NewInt64Coin(common.DenomStable, 50), ), expectedFinalPool: mock.DexPool( /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 200), - sdk.NewInt64Coin("unusd", 50), + sdk.NewInt64Coin(common.DenomStable, 50), ), /*shares=*/ 100, ), @@ -68,12 +69,12 @@ func TestSwapExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), tokenIn: sdk.NewInt64Coin("unibi", 100), - tokenOutDenom: "unusd", + tokenOutDenom: common.DenomStable, expectedUserFinalFunds: sdk.NewCoins( sdk.NewInt64Coin("unibi", 1), ), @@ -81,7 +82,7 @@ func TestSwapExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -96,12 +97,12 @@ func TestSwapExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), tokenIn: sdk.NewInt64Coin("foo", 100), - tokenOutDenom: "unusd", + tokenOutDenom: common.DenomStable, expectedUserFinalFunds: sdk.NewCoins( sdk.NewInt64Coin("foo", 100), ), @@ -109,7 +110,7 @@ func TestSwapExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -124,7 +125,7 @@ func TestSwapExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -137,7 +138,7 @@ func TestSwapExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -152,7 +153,7 @@ func TestSwapExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -165,7 +166,7 @@ func TestSwapExactAmountIn(t *testing.T) { /*poolId=*/ 1, /*assets=*/ sdk.NewCoins( sdk.NewInt64Coin("unibi", 100), - sdk.NewInt64Coin("unusd", 100), + sdk.NewInt64Coin(common.DenomStable, 100), ), /*shares=*/ 100, ), @@ -176,7 +177,7 @@ func TestSwapExactAmountIn(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) // fund pool account poolAddr := sample.AccAddress() diff --git a/x/dex/simulation/operations.go b/x/dex/simulation/operations.go index 74907395c..fd3246e92 100644 --- a/x/dex/simulation/operations.go +++ b/x/dex/simulation/operations.go @@ -308,9 +308,9 @@ func genPoolAssets( func fundAccountWithTokens(ctx sdk.Context, address sdk.AccAddress, bk types.BankKeeper) { million := 1_000_000 newTokens := sdk.NewCoins( - sdk.NewCoin(common.GovDenom, sdk.NewInt(int64(10*million))), - sdk.NewCoin(common.CollDenom, sdk.NewInt(int64(10*million))), - sdk.NewCoin(common.StableDenom, sdk.NewInt(int64(10*million))), + sdk.NewCoin(common.DenomGov, sdk.NewInt(int64(10*million))), + sdk.NewCoin(common.DenomColl, sdk.NewInt(int64(10*million))), + sdk.NewCoin(common.DenomStable, sdk.NewInt(int64(10*million))), ) err := bk.MintCoins(ctx, types.ModuleName, newTokens) diff --git a/x/dex/types/params.go b/x/dex/types/params.go index 6b0e28a50..b9770754f 100644 --- a/x/dex/types/params.go +++ b/x/dex/types/params.go @@ -30,12 +30,12 @@ func NewParams(startingPoolNumber uint64, poolCreationFee sdk.Coins, whitelisted func DefaultParams() Params { return Params{ StartingPoolNumber: 1, - PoolCreationFee: sdk.NewCoins(sdk.NewInt64Coin(common.GovDenom, 1000_000_000)), // 1000 NIBI + PoolCreationFee: sdk.NewCoins(sdk.NewInt64Coin(common.DenomGov, 1000_000_000)), // 1000 NIBI WhitelistedAsset: []string{ - common.GovDenom, - common.CollDenom, - common.StableDenom, - common.StakeTokenDenom, + common.DenomGov, + common.DenomColl, + common.DenomStable, + common.DenomStakeToken, }, } } diff --git a/x/epochs/abci_test.go b/x/epochs/abci_test.go index f698f114b..de803d14e 100644 --- a/x/epochs/abci_test.go +++ b/x/epochs/abci_test.go @@ -10,7 +10,7 @@ import ( "github.com/NibiruChain/nibiru/app" "github.com/NibiruChain/nibiru/x/epochs" "github.com/NibiruChain/nibiru/x/epochs/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestEpochInfoChangesBeginBlockerAndInitGenesis(t *testing.T) { @@ -97,7 +97,7 @@ func TestEpochInfoChangesBeginBlockerAndInitGenesis(t *testing.T) { } for _, test := range tests { - app, ctx = testutilapp.NewNibiruApp(true) + app, ctx = testapp.NewNibiruAppAndContext(true) // On init genesis, default epochs information is set // To check init genesis again, should make it fresh status @@ -138,7 +138,7 @@ func TestEpochInfoChangesBeginBlockerAndInitGenesis(t *testing.T) { } func TestEpochStartingOneMonthAfterInitGenesis(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) // On init genesis, default epochs information is set // To check init genesis again, should make it fresh status @@ -210,7 +210,7 @@ func TestLegacyEpochSerialization(t *testing.T) { } now := time.Now() - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) // On init genesis, default epochs information is set // To check init genesis again, should make it fresh status epochInfos := app.EpochsKeeper.AllEpochInfos(ctx) diff --git a/x/epochs/genesis_test.go b/x/epochs/genesis_test.go index 549196586..844355782 100644 --- a/x/epochs/genesis_test.go +++ b/x/epochs/genesis_test.go @@ -8,11 +8,11 @@ import ( "github.com/NibiruChain/nibiru/x/epochs" "github.com/NibiruChain/nibiru/x/epochs/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestEpochsExportGenesis(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) chainStartTime := ctx.BlockTime() chainStartHeight := ctx.BlockHeight() @@ -46,7 +46,7 @@ func TestEpochsExportGenesis(t *testing.T) { } func TestEpochsInitGenesis(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) // On init genesis, default epochs information is set // To check init genesis again, should make it fresh status epochInfos := app.EpochsKeeper.AllEpochInfos(ctx) diff --git a/x/epochs/keeper/keeper_test.go b/x/epochs/keeper/keeper_test.go index 260442366..b6734bcb5 100644 --- a/x/epochs/keeper/keeper_test.go +++ b/x/epochs/keeper/keeper_test.go @@ -11,7 +11,7 @@ import ( "github.com/NibiruChain/nibiru/app" "github.com/NibiruChain/nibiru/x/epochs/keeper" "github.com/NibiruChain/nibiru/x/epochs/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) type KeeperTestSuite struct { @@ -23,7 +23,7 @@ type KeeperTestSuite struct { } func (suite *KeeperTestSuite) SetupTest() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) suite.app = nibiruApp suite.ctx = ctx diff --git a/x/incentivization/keeper/keeper_test.go b/x/incentivization/keeper/keeper_test.go index 6c2fae4d2..0304a2887 100644 --- a/x/incentivization/keeper/keeper_test.go +++ b/x/incentivization/keeper/keeper_test.go @@ -14,13 +14,13 @@ import ( "github.com/stretchr/testify/require" "github.com/NibiruChain/nibiru/x/incentivization/keeper" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestKeeper_CreateIncentivizationProgram(t *testing.T) { t.Run("success", func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(false) + app, ctx := testapp.NewNibiruAppAndContext(false) createdProgram, err := app.IncentivizationKeeper.CreateIncentivizationProgram(ctx, "denom", 48*time.Hour, ctx.BlockTime(), 1000) require.NoError(t, err) @@ -33,7 +33,7 @@ func TestKeeper_CreateIncentivizationProgram(t *testing.T) { require.Equal(t, authtypes.NewModuleAddress(keeper.NewEscrowAccountName(0)).String(), createdProgram.EscrowAddress) }) t.Run("min lockup duration too low", func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(false) + app, ctx := testapp.NewNibiruAppAndContext(false) _, err := app.IncentivizationKeeper.CreateIncentivizationProgram(ctx, "denom", 1*time.Second, ctx.BlockTime(), keeper.MinEpochs) @@ -41,7 +41,7 @@ func TestKeeper_CreateIncentivizationProgram(t *testing.T) { }) t.Run("epochs lower than minimum", func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(false) + app, ctx := testapp.NewNibiruAppAndContext(false) _, err := app.IncentivizationKeeper.CreateIncentivizationProgram(ctx, "denom", 48*time.Hour, ctx.BlockTime(), keeper.MinEpochs-1) @@ -49,7 +49,7 @@ func TestKeeper_CreateIncentivizationProgram(t *testing.T) { }) t.Run("start time before block time", func(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) ctx := app.NewContext(false, tmproto.Header{Time: time.Now()}) _, err := app.IncentivizationKeeper.CreateIncentivizationProgram(ctx, "denom", 48*time.Hour, ctx.BlockTime().Add(-1*time.Second), keeper.MinEpochs+1) @@ -59,7 +59,7 @@ func TestKeeper_CreateIncentivizationProgram(t *testing.T) { func TestKeeper_FundIncentivizationProgram(t *testing.T) { t.Run("success", func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(false) + app, ctx := testapp.NewNibiruAppAndContext(false) addr := sample.AccAddress() fundingAmount := sdk.NewCoins(sdk.NewInt64Coin("test", 100)) require.NoError(t, simapp.FundAccount(app.BankKeeper, ctx, addr, fundingAmount)) diff --git a/x/incentivization/keeper/servers_test.go b/x/incentivization/keeper/servers_test.go index a6c584516..ad2ad154c 100644 --- a/x/incentivization/keeper/servers_test.go +++ b/x/incentivization/keeper/servers_test.go @@ -7,6 +7,7 @@ import ( "github.com/cosmos/cosmos-sdk/simapp" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/query" @@ -15,12 +16,11 @@ import ( "github.com/NibiruChain/nibiru/x/incentivization/keeper" "github.com/NibiruChain/nibiru/x/incentivization/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" ) func TestMsgServer_CreateIncentivizationProgram(t *testing.T) { t.Run("success", func(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) s := keeper.NewMsgServer(app.IncentivizationKeeper) ctx := app.NewContext(false, tmproto.Header{Time: time.Now()}) @@ -55,7 +55,7 @@ func TestMsgServer_CreateIncentivizationProgram(t *testing.T) { func TestMsgServer_FundIncentivizationProgram(t *testing.T) { t.Run("success", func(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) s := keeper.NewMsgServer(app.IncentivizationKeeper) ctx := app.NewContext(false, tmproto.Header{Time: time.Now()}) @@ -94,7 +94,7 @@ func TestMsgServer_FundIncentivizationProgram(t *testing.T) { } func TestQueryServer_IncentivizationProgram(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) q := keeper.NewQueryServer(app.IncentivizationKeeper) ctx := app.NewContext(false, tmproto.Header{Time: time.Now()}) @@ -108,7 +108,7 @@ func TestQueryServer_IncentivizationProgram(t *testing.T) { } func TestQueryServer_IncentivizationPrograms(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) q := keeper.NewQueryServer(app.IncentivizationKeeper) ctx := app.NewContext(false, tmproto.Header{Time: time.Now()}) diff --git a/x/incentivization/module_test.go b/x/incentivization/module_test.go index 2fbba320b..a7dc09adb 100644 --- a/x/incentivization/module_test.go +++ b/x/incentivization/module_test.go @@ -12,11 +12,11 @@ import ( "github.com/NibiruChain/nibiru/x/incentivization" "github.com/NibiruChain/nibiru/x/incentivization/keeper" "github.com/NibiruChain/nibiru/x/incentivization/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestAppModule_InitGenesis_ExportGenesis(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) am := incentivization.NewAppModule(app.AppCodec(), app.IncentivizationKeeper, app.AccountKeeper) ctxUncached := app.NewContext(false, tmproto.Header{Time: time.Now()}) diff --git a/x/lockup/client/cli/cli_test.go b/x/lockup/client/cli/cli_test.go index 35e398a91..176c9d0ff 100644 --- a/x/lockup/client/cli/cli_test.go +++ b/x/lockup/client/cli/cli_test.go @@ -15,6 +15,7 @@ import ( "github.com/NibiruChain/nibiru/app" "github.com/NibiruChain/nibiru/x/lockup/client/cli" testutilcli "github.com/NibiruChain/nibiru/x/testutil/cli" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) type IntegrationTestSuite struct { @@ -33,17 +34,18 @@ func (s *IntegrationTestSuite) SetupSuite() { s.T().Log("setting up lockup CLI testing suite") - s.cfg = testutilcli.DefaultConfig() - genesisState := app.ModuleBasics.DefaultGenesis(s.cfg.Codec) + app.SetPrefixes(app.AccountAddressPrefix) + encCfg := app.MakeTestEncodingConfig() + defaultAppGenesis := app.ModuleBasics.DefaultGenesis(encCfg.Marshaler) + testAppGenesis := testapp.NewTestGenesisState(encCfg.Marshaler, defaultAppGenesis) + s.cfg = testutilcli.BuildNetworkConfig(testAppGenesis) - s.cfg.GenesisState = genesisState s.cfg.StartingTokens = sdk.NewCoins( sdk.NewInt64Coin("ATOM", 1_000_000), sdk.NewInt64Coin("OSMO", 1_000_000), sdk.NewInt64Coin("unibi", 1_000_000_000)) - app.SetPrefixes(app.AccountAddressPrefix) - s.network = testutilcli.New(s.T(), s.cfg) + s.network = testutilcli.NewNetwork(s.T(), s.cfg) _, err := s.network.WaitForHeight(1) require.NoError(s.T(), err) diff --git a/x/lockup/keeper/keeper_test.go b/x/lockup/keeper/keeper_test.go index 1bb9b0857..ddb072841 100644 --- a/x/lockup/keeper/keeper_test.go +++ b/x/lockup/keeper/keeper_test.go @@ -11,8 +11,8 @@ import ( "github.com/NibiruChain/nibiru/x/lockup/keeper" "github.com/NibiruChain/nibiru/x/lockup/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestCreateLock(t *testing.T) { @@ -45,7 +45,7 @@ func TestCreateLock(t *testing.T) { for _, testcase := range tests { tc := testcase t.Run(tc.name, func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) require.NoError(t, simapp.FundAccount(app.BankKeeper, ctx, tc.ownerAddr, tc.accountInitialFunds)) lock, err := app.LockupKeeper.LockTokens(ctx, tc.ownerAddr, tc.coins, tc.duration) @@ -68,7 +68,7 @@ func TestCreateLock(t *testing.T) { func TestLockupKeeper_InitiateUnlocking(t *testing.T) { t.Run("success", func(t *testing.T) { - app, _ := testutilapp.NewNibiruApp(false) + app, _ := testapp.NewNibiruAppAndContext(false) addr := sample.AccAddress() coins := sdk.NewCoins(sdk.NewCoin("test", sdk.NewInt(1000))) @@ -90,12 +90,12 @@ func TestLockupKeeper_InitiateUnlocking(t *testing.T) { require.Equal(t, updatedLock.EndTime, ctx.BlockTime().Add(lock.Duration)) }) t.Run("err lock does not exist", func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(false) + app, ctx := testapp.NewNibiruAppAndContext(false) _, err := app.LockupKeeper.InitiateUnlocking(ctx, 0) require.ErrorIs(t, err, types.ErrLockupNotFound) }) t.Run("err already unlocking", func(t *testing.T) { - app, _ := testutilapp.NewNibiruApp(false) + app, _ := testapp.NewNibiruAppAndContext(false) addr := sample.AccAddress() coins := sdk.NewCoins(sdk.NewCoin("test", sdk.NewInt(1000))) @@ -119,7 +119,7 @@ func TestLockupKeeper_InitiateUnlocking(t *testing.T) { func TestLockupKeeper_UnlockTokens(t *testing.T) { t.Run("success", func(t *testing.T) { - app, _ := testutilapp.NewNibiruApp(true) + app, _ := testapp.NewNibiruAppAndContext(true) addr := sample.AccAddress() coins := sdk.NewCoins(sdk.NewCoin("test", sdk.NewInt(1000))) @@ -146,14 +146,14 @@ func TestLockupKeeper_UnlockTokens(t *testing.T) { }) t.Run("lock not found", func(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) _, err := app.LockupKeeper.UnlockTokens(ctx, 1) require.ErrorIs(t, err, types.ErrLockupNotFound) }) t.Run("lock not matured", func(t *testing.T) { - app, _ := testutilapp.NewNibiruApp(true) + app, _ := testapp.NewNibiruAppAndContext(true) addr := sample.AccAddress() coins := sdk.NewCoins(sdk.NewCoin("test", sdk.NewInt(1000))) @@ -171,7 +171,7 @@ func TestLockupKeeper_UnlockTokens(t *testing.T) { func TestLockupKeeper_AccountLockedCoins(t *testing.T) { t.Run("success", func(t *testing.T) { - app, _ := testutilapp.NewNibiruApp(true) + app, _ := testapp.NewNibiruAppAndContext(true) addr := sample.AccAddress() ctx := app.NewContext(false, tmproto.Header{Time: time.Now()}) @@ -197,7 +197,7 @@ func TestLockupKeeper_AccountLockedCoins(t *testing.T) { func TestLockupKeeper_AccountUnlockedCoins(t *testing.T) { t.Run("success", func(t *testing.T) { - app, _ := testutilapp.NewNibiruApp(false) + app, _ := testapp.NewNibiruAppAndContext(false) addr := sample.AccAddress() ctx := app.NewContext(false, tmproto.Header{Time: time.Now()}) @@ -227,7 +227,7 @@ func TestLockupKeeper_AccountUnlockedCoins(t *testing.T) { func TestLockupKeeper_LockedCoins(t *testing.T) { t.Run("success", func(t *testing.T) { - app, _ := testutilapp.NewNibiruApp(false) + app, _ := testapp.NewNibiruAppAndContext(false) ctx := app.NewContext(false, tmproto.Header{Time: time.Now()}) addr := sample.AccAddress() @@ -258,7 +258,7 @@ func TestLockupKeeper_LockedCoins(t *testing.T) { func TestLockupKeeper_UnlockAvailableCoins(t *testing.T) { t.Run("success", func(t *testing.T) { - app, _ := testutilapp.NewNibiruApp(false) + app, _ := testapp.NewNibiruAppAndContext(false) ctx := app.NewContext(false, tmproto.Header{Time: time.Now()}) addr := sample.AccAddress() @@ -290,7 +290,7 @@ func TestLockupKeeper_UnlockAvailableCoins(t *testing.T) { func TestLockupKeeper_LocksByDenomUnlockingAfter(t *testing.T) { t.Run("success", func(t *testing.T) { - app, _ := testutilapp.NewNibiruApp(false) + app, _ := testapp.NewNibiruAppAndContext(false) ctx := app.NewContext(false, tmproto.Header{Time: time.Now().UTC()}) addr := sample.AccAddress() diff --git a/x/lockup/keeper/msg_server_test.go b/x/lockup/keeper/msg_server_test.go index f609e544e..295238c04 100644 --- a/x/lockup/keeper/msg_server_test.go +++ b/x/lockup/keeper/msg_server_test.go @@ -13,12 +13,12 @@ import ( "github.com/NibiruChain/nibiru/x/lockup/keeper" "github.com/NibiruChain/nibiru/x/lockup/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestMsgServer_LockTokens(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) uncachedCtx := app.NewContext(false, tmproto.Header{Time: time.Now()}) s := keeper.NewMsgServerImpl(app.LockupKeeper) @@ -38,7 +38,7 @@ func TestMsgServer_LockTokens(t *testing.T) { } func TestMsgServer_InitiateUnlock(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) uncachedCtx := app.NewContext(false, tmproto.Header{Time: time.Now()}) s := keeper.NewMsgServerImpl(app.LockupKeeper) @@ -64,7 +64,7 @@ func TestMsgServer_InitiateUnlock(t *testing.T) { } func TestMsgServer_Unlock(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) uncachedCtx := app.NewContext(false, tmproto.Header{Time: time.Now()}) s := keeper.NewMsgServerImpl(app.LockupKeeper) @@ -98,7 +98,7 @@ func TestMsgServer_Unlock(t *testing.T) { } func TestQueryServer_Lock(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) uncachedCtx := app.NewContext(false, tmproto.Header{Time: time.Now()}) s := keeper.NewMsgServerImpl(app.LockupKeeper) q := keeper.NewQueryServerImpl(app.LockupKeeper) @@ -127,7 +127,7 @@ func TestQueryServer_Lock(t *testing.T) { } func TestQueryServer_LockedCoins(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) uncachedCtx := app.NewContext(false, tmproto.Header{Time: time.Now()}) s := keeper.NewMsgServerImpl(app.LockupKeeper) q := keeper.NewQueryServerImpl(app.LockupKeeper) @@ -153,7 +153,7 @@ func TestQueryServer_LockedCoins(t *testing.T) { } func TestQueryServer_LocksByAddress(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) uncachedCtx := app.NewContext(false, tmproto.Header{Time: time.Now()}) s := keeper.NewMsgServerImpl(app.LockupKeeper) q := keeper.NewQueryServerImpl(app.LockupKeeper) diff --git a/x/lockup/keeper/state_test.go b/x/lockup/keeper/state_test.go index 370346f7b..9e758a0ee 100644 --- a/x/lockup/keeper/state_test.go +++ b/x/lockup/keeper/state_test.go @@ -11,12 +11,12 @@ import ( "github.com/NibiruChain/nibiru/x/lockup/keeper" "github.com/NibiruChain/nibiru/x/lockup/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestLockState(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) addr := sample.AccAddress() lock := &types.Lock{ LockId: 0, @@ -62,7 +62,7 @@ func Test_LocksState_232(t *testing.T) { addr1 := sdk.AccAddress{197, 74, 130, 194, 229, 233, 119, 113, 119, 172, 13, 56, 95, 110, 234, 199, 255, 102, 24, 142} addr2 := sdk.AccAddress{198, 74, 130, 194, 229, 233, 119, 113, 119, 172, 13, 56, 95, 110, 234, 199, 255, 102, 24, 143} - app, _ := testutilapp.NewNibiruApp(false) + app, _ := testapp.NewNibiruAppAndContext(false) ctx := app.NewContext(false, tmproto.Header{Time: time.Now()}) // we create two locks for each addr one expired the other one not diff --git a/x/lockup/module_test.go b/x/lockup/module_test.go index c2be06d5b..e802777df 100644 --- a/x/lockup/module_test.go +++ b/x/lockup/module_test.go @@ -11,12 +11,12 @@ import ( "github.com/NibiruChain/nibiru/x/lockup" "github.com/NibiruChain/nibiru/x/lockup/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestAppModule_ExportGenesis_ImportGenesis(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) am := lockup.NewAppModule(app.AppCodec(), app.LockupKeeper, app.AccountKeeper, app.BankKeeper) ctxUncached := app.NewContext(false, tmproto.Header{Time: time.Now()}) diff --git a/x/perp/client/cli/cli_test.go b/x/perp/client/cli/cli_test.go index 893fffa0f..723bf0e48 100644 --- a/x/perp/client/cli/cli_test.go +++ b/x/perp/client/cli/cli_test.go @@ -28,7 +28,7 @@ import ( var commonArgs = []string{ fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation), fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock), - fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(common.GovDenom, sdk.NewInt(10))).String()), + fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(common.DenomGov, sdk.NewInt(10))).String()), } type IntegrationTestSuite struct { @@ -39,33 +39,23 @@ type IntegrationTestSuite struct { users []sdk.AccAddress } -const ( - oracleAddress = "nibi1zaavvzxez0elundtn32qnk9lkm8kmcsz44g7xl" -) - // NewPricefeedGen returns an x/pricefeed GenesisState to specify the module parameters. func NewPricefeedGen() *pftypes.GenesisState { - oracle, err := sdk.AccAddressFromBech32(oracleAddress) - if err != nil { - panic(err) - } + const oracleAddress = "nibi1zaavvzxez0elundtn32qnk9lkm8kmcsz44g7xl" + oracle := sdk.MustAccAddressFromBech32(oracleAddress) + pairs := common.AssetPairs{common.PairTestStable} return &pftypes.GenesisState{ - Params: pftypes.Params{ - Pairs: []pftypes.Pair{ - {Token0: common.TestStablePool.Token0, - Token1: common.TestStablePool.Token1, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }, - }, + Params: pftypes.Params{Pairs: pairs}, PostedPrices: []pftypes.PostedPrice{ { - PairID: common.TestStablePool.PairID(), - OracleAddress: oracle, - Price: sdk.OneDec(), - Expiry: time.Now().Add(1 * time.Hour), + PairID: common.PairTestStable.String(), + Oracle: oracle.String(), + Price: sdk.OneDec(), + Expiry: time.Now().Add(1 * time.Hour), }, }, + GenesisOracles: []string{oracle.String()}, } } @@ -81,11 +71,12 @@ func (s *IntegrationTestSuite) SetupSuite() { s.T().Log("setting up integration test suite") - s.cfg = testutilcli.DefaultConfig() - app.SetPrefixes(app.AccountAddressPrefix) + encodingConfig := app.MakeTestEncodingConfig() + defaultAppGenesis := app.NewDefaultGenesisState(encodingConfig.Marshaler) + s.cfg = testutilcli.BuildNetworkConfig(defaultAppGenesis) - genesisState := app.ModuleBasics.DefaultGenesis(s.cfg.Codec) + genesisState := defaultAppGenesis // setup vpool vpoolGenesis := vpooltypes.DefaultGenesis() @@ -107,7 +98,7 @@ func (s *IntegrationTestSuite) SetupSuite() { MaxOracleSpreadRatio: sdk.MustNewDecFromStr("0.2"), }, { - Pair: common.TestStablePool.String(), + Pair: common.PairTestStable.String(), BaseAssetReserve: sdk.MustNewDecFromStr("100"), QuoteAssetReserve: sdk.MustNewDecFromStr("600"), @@ -135,7 +126,7 @@ func (s *IntegrationTestSuite) SetupSuite() { }, }, { - Pair: common.TestStablePool.String(), + Pair: common.PairTestStable.String(), CumulativePremiumFractions: []sdk.Dec{ sdk.ZeroDec(), }, @@ -149,7 +140,7 @@ func (s *IntegrationTestSuite) SetupSuite() { s.cfg.GenesisState = genesisState - s.network = testutilcli.New(s.T(), s.cfg) + s.network = testutilcli.NewNetwork(s.T(), s.cfg) _, err := s.network.WaitForHeight(1) s.Require().NoError(err) @@ -165,10 +156,10 @@ func (s *IntegrationTestSuite) SetupSuite() { _, err = testutilcli.FillWalletFromValidator(user1, sdk.NewCoins( sdk.NewInt64Coin(s.cfg.BondDenom, 20_000), - sdk.NewInt64Coin(common.GovDenom, 100_000_000), - sdk.NewInt64Coin(common.CollDenom, 100_000_000), - sdk.NewInt64Coin(common.TestTokenDenom, 50_000_000), - sdk.NewInt64Coin(common.StableDenom, 50_000_000), + sdk.NewInt64Coin(common.DenomGov, 100_000_000), + sdk.NewInt64Coin(common.DenomColl, 100_000_000), + sdk.NewInt64Coin(common.DenomTestToken, 50_000_000), + sdk.NewInt64Coin(common.DenomStable, 50_000_000), ), val, s.cfg.BondDenom, @@ -370,7 +361,7 @@ func (s *IntegrationTestSuite) TestGetPrices() { func (s *IntegrationTestSuite) TestRemoveMargin() { // Set up the user accounts val := s.network.Validators[0] - pair := common.TestStablePool + pair := common.PairTestStable // Open a position with first user s.T().Log("opening a position with user 1....") @@ -395,7 +386,7 @@ func (s *IntegrationTestSuite) TestRemoveMargin() { "--from", s.users[0].String(), pair.String(), - fmt.Sprintf("%s%s", "100", common.TestStablePool.Token1), // Amount + fmt.Sprintf("%s%s", "100", common.PairTestStable.Token1), // Amount } out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.RemoveMarginCmd(), append(args, commonArgs...)) if err != nil { diff --git a/x/perp/client/cli/query.go b/x/perp/client/cli/query.go index a7fca25f3..041e4be23 100644 --- a/x/perp/client/cli/query.go +++ b/x/perp/client/cli/query.go @@ -83,7 +83,7 @@ func CmdQueryPosition() *cobra.Command { return fmt.Errorf("invalid trader address: %w", err) } - tokenPair, err := common.NewAssetPairFromStr(args[1]) + tokenPair, err := common.NewAssetPair(args[1]) if err != nil { return err } diff --git a/x/perp/client/cli/tx.go b/x/perp/client/cli/tx.go index 0c1a8d98a..1eb9488e5 100644 --- a/x/perp/client/cli/tx.go +++ b/x/perp/client/cli/tx.go @@ -58,7 +58,7 @@ func OpenPositionCmd() *cobra.Command { return fmt.Errorf("invalid side: %s", args[0]) } - assetPair, err := common.NewAssetPairFromStr(args[1]) + assetPair, err := common.NewAssetPair(args[1]) if err != nil { return err } diff --git a/x/perp/genesis_test.go b/x/perp/genesis_test.go index d71da37a6..65f65d0b1 100644 --- a/x/perp/genesis_test.go +++ b/x/perp/genesis_test.go @@ -11,13 +11,13 @@ import ( "github.com/NibiruChain/nibiru/x/perp" "github.com/NibiruChain/nibiru/x/perp/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestGenesis(t *testing.T) { t.Run("success", func(t *testing.T) { - app := testutilapp.NewTestApp(false) + app := testapp.NewNibiruApp(false) ctxUncached := app.NewContext(false, tmproto.Header{}) ctx, _ := ctxUncached.CacheContext() // fund module accounts diff --git a/x/perp/keeper/calc.go b/x/perp/keeper/calc.go index c69f1f3ee..50b4ac386 100644 --- a/x/perp/keeper/calc.go +++ b/x/perp/keeper/calc.go @@ -94,7 +94,7 @@ position without making it go underwater. func (k Keeper) calcFreeCollateral( ctx sdk.Context, pos types.Position, fundingPayment sdk.Dec, ) (accountExcessEquity sdk.Int, err error) { - pair, err := common.NewAssetPairFromStr(pos.Pair) + pair, err := common.NewAssetPair(pos.Pair) if err != nil { return sdk.Int{}, common.ErrInvalidTokenPair } diff --git a/x/perp/keeper/calc_test.go b/x/perp/keeper/calc_test.go index cddfe9ae6..11f45d708 100644 --- a/x/perp/keeper/calc_test.go +++ b/x/perp/keeper/calc_test.go @@ -9,8 +9,8 @@ import ( "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/perp/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestCalcRemainMarginWithFundingPayment(t *testing.T) { @@ -21,7 +21,7 @@ func TestCalcRemainMarginWithFundingPayment(t *testing.T) { { name: "get - no positions set raises vpool not found error", test: func() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) marginDelta := sdk.OneDec() _, err := nibiruApp.PerpKeeper.CalcRemainMarginWithFundingPayment( @@ -35,7 +35,7 @@ func TestCalcRemainMarginWithFundingPayment(t *testing.T) { { name: "fail - invalid token pair passed to calculation", test: func() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) the3pool := "dai:usdc:usdt" marginDelta := sdk.OneDec() @@ -49,9 +49,9 @@ func TestCalcRemainMarginWithFundingPayment(t *testing.T) { name: "signedRemainMargin negative bc of marginDelta", test: func() { t.Log("Setup Nibiru app, pair, and trader") - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) trader := sample.AccAddress() - pair, err := common.NewAssetPairFromStr("osmo:nusd") + pair, err := common.NewAssetPair("osmo:nusd") require.NoError(t, err) t.Log("Set vpool defined by pair on VpoolKeeper") @@ -99,9 +99,9 @@ func TestCalcRemainMarginWithFundingPayment(t *testing.T) { name: "large fPayment lowers pos value by half", test: func() { t.Log("Setup Nibiru app, pair, and trader") - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) trader := sample.AccAddress() - pair, err := common.NewAssetPairFromStr("osmo:nusd") + pair, err := common.NewAssetPair("osmo:nusd") require.NoError(t, err) t.Log("Set vpool defined by pair on VpoolKeeper") @@ -166,7 +166,7 @@ func TestCalcRemainMarginWithFundingPayment(t *testing.T) { } func TestCalcPerpTxFee(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) perpKeeper := &nibiruApp.PerpKeeper currentParams := perpKeeper.GetParams(ctx) diff --git a/x/perp/keeper/clearing_house_test.go b/x/perp/keeper/clearing_house_test.go index a10570431..febce8da1 100644 --- a/x/perp/keeper/clearing_house_test.go +++ b/x/perp/keeper/clearing_house_test.go @@ -41,7 +41,7 @@ func TestKeeper_getLatestCumulativePremiumFraction(t *testing.T) { name: "happy path", test: func() { keeper, _, ctx := getKeeper(t) - pair := fmt.Sprintf("%s%s%s", common.GovDenom, common.PairSeparator, common.StableDenom) + pair := fmt.Sprintf("%s%s%s", common.DenomGov, common.PairSeparator, common.DenomStable) metadata := &types.PairMetadata{ Pair: pair, @@ -52,7 +52,7 @@ func TestKeeper_getLatestCumulativePremiumFraction(t *testing.T) { } keeper.PairMetadataState(ctx).Set(metadata) - tokenPair, err := common.NewAssetPairFromStr(pair) + tokenPair, err := common.NewAssetPair(pair) require.NoError(t, err) latestCumulativePremiumFraction, err := keeper. getLatestCumulativePremiumFraction(ctx, tokenPair) @@ -2732,7 +2732,7 @@ func TestClosePosition(t *testing.T) { perpKeeper, mocks, ctx := getKeeper(t) traderAddr, err := sdk.AccAddressFromBech32(tc.initialPosition.TraderAddress) require.NoError(t, err) - assetPair, err := common.NewAssetPairFromStr(tc.initialPosition.Pair) + assetPair, err := common.NewAssetPair(tc.initialPosition.Pair) require.NoError(t, err) t.Log("set position") @@ -2902,7 +2902,7 @@ func TestClosePositionWithBadDebt(t *testing.T) { perpKeeper, mocks, ctx := getKeeper(t) traderAddr, err := sdk.AccAddressFromBech32(tc.initialPosition.TraderAddress) require.NoError(t, err) - assetPair, err := common.NewAssetPairFromStr(tc.initialPosition.Pair) + assetPair, err := common.NewAssetPair(tc.initialPosition.Pair) require.NoError(t, err) t.Log("set position") diff --git a/x/perp/keeper/grpc_query.go b/x/perp/keeper/grpc_query.go index e5a29ac54..b3011855f 100644 --- a/x/perp/keeper/grpc_query.go +++ b/x/perp/keeper/grpc_query.go @@ -34,7 +34,7 @@ func (q queryServer) TraderPosition( ctx := sdk.UnwrapSDKContext(goCtx) - pair, err := common.NewAssetPairFromStr(req.TokenPair) + pair, err := common.NewAssetPair(req.TokenPair) if err != nil { return nil, err } diff --git a/x/perp/keeper/grpc_query_test.go b/x/perp/keeper/grpc_query_test.go index b31d6a4bc..705038a89 100644 --- a/x/perp/keeper/grpc_query_test.go +++ b/x/perp/keeper/grpc_query_test.go @@ -11,19 +11,19 @@ import ( "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/perp/keeper" "github.com/NibiruChain/nibiru/x/perp/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestQueryPosition_Ok(t *testing.T) { t.Log("initialize keeper") - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) perpKeeper := &nibiruApp.PerpKeeper queryServer := keeper.NewQuerier(*perpKeeper) trader := sample.AccAddress() - vpoolPair, err := common.NewAssetPairFromStr("btc:nusd") + vpoolPair, err := common.NewAssetPair("btc:nusd") require.NoError(t, err) oldPosition := &types.Position{ diff --git a/x/perp/keeper/hooks.go b/x/perp/keeper/hooks.go index a174ba9fd..0af427b88 100644 --- a/x/perp/keeper/hooks.go +++ b/x/perp/keeper/hooks.go @@ -18,7 +18,7 @@ func (k Keeper) AfterEpochEnd(ctx sdk.Context, epochIdentifier string, _ int64) return } for _, md := range k.PairMetadataState(ctx).GetAll() { - assetPair, err := common.NewAssetPairFromStr(md.Pair) + assetPair, err := common.NewAssetPair(md.Pair) if err != nil { ctx.Logger().Error("invalid asset pair", "assetPair", md.Pair, "error", err) continue @@ -36,7 +36,7 @@ func (k Keeper) AfterEpochEnd(ctx sdk.Context, epochIdentifier string, _ int64) ctx.Logger().Error("index price is zero", "assetPair", assetPair) continue } - markTWAPPrice, err := k.VpoolKeeper.GetCurrentTWAPPrice(ctx, assetPair.Token0, assetPair.Token1) + markTWAPPrice, err := k.VpoolKeeper.GetCurrentTWAPPrice(ctx, assetPair) if err != nil { ctx.Logger().Error("failed to fetch twap mark price", "assetPair", assetPair, "error", err) continue diff --git a/x/perp/keeper/hooks_test.go b/x/perp/keeper/hooks_test.go index 38b83e0c8..5539c7274 100644 --- a/x/perp/keeper/hooks_test.go +++ b/x/perp/keeper/hooks_test.go @@ -16,7 +16,7 @@ import ( vpooltypes "github.com/NibiruChain/nibiru/x/vpool/types" ) -var token0, token1 = BtcNusdPair.Token0, BtcNusdPair.Token1 +var pair = BtcNusdPair func TestEndOfEpochTwapCalculation(t *testing.T) { tests := []struct { @@ -97,13 +97,13 @@ func setMockPrices(ctx sdk.Context, mocks mockedDependencies, indexPrice, markPr ) } mocks.mockPricefeedKeeper.EXPECT(). - GetCurrentTWAPPrice(ctx, token0, token1). + GetCurrentTWAPPrice(ctx, pair.Token0, pair.Token1). Return(pftypes.CurrentTWAP{ PairID: BtcNusdPair.String(), Price: sdk.NewDec(indexPrice), }, nil).MaxTimes(1) mocks.mockVpoolKeeper.EXPECT(). - GetCurrentTWAPPrice(ctx, token0, token1). + GetCurrentTWAPPrice(ctx, pair). Return(vpooltypes.CurrentTWAP{ PairID: BtcNusdPair.String(), Price: sdk.NewDec(markPrice), diff --git a/x/perp/keeper/keeper_test.go b/x/perp/keeper/keeper_test.go index 63c18f6f1..ef3ba21b0 100644 --- a/x/perp/keeper/keeper_test.go +++ b/x/perp/keeper/keeper_test.go @@ -6,7 +6,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/NibiruChain/nibiru/x/perp/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" "github.com/stretchr/testify/require" ) @@ -38,7 +38,7 @@ func TestGetAndSetParams(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) perpKeeper := &nibiruApp.PerpKeeper params := tc.requiredParams() @@ -51,7 +51,7 @@ func TestGetAndSetParams(t *testing.T) { func TestGetAndSetParams_Errors(t *testing.T) { t.Run("Calling Get without setting causes a panic", func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(false) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(false) perpKeeper := &nibiruApp.PerpKeeper require.Panics( diff --git a/x/perp/keeper/liquidate.go b/x/perp/keeper/liquidate.go index cc84887b6..c985742d1 100644 --- a/x/perp/keeper/liquidate.go +++ b/x/perp/keeper/liquidate.go @@ -33,7 +33,7 @@ func (k Keeper) Liquidate( } // validate pair - pair, err := common.NewAssetPairFromStr(msg.TokenPair) + pair, err := common.NewAssetPair(msg.TokenPair) if err != nil { return res, err } @@ -118,7 +118,7 @@ func (k Keeper) ExecuteFullLiquidation( ) (liquidationResp types.LiquidateResp, err error) { params := k.GetParams(ctx) - pair, err := common.NewAssetPairFromStr(position.Pair) + pair, err := common.NewAssetPair(position.Pair) if err != nil { return types.LiquidateResp{}, err } @@ -224,7 +224,7 @@ func (k Keeper) distributeLiquidateRewards( } // validate pair - pair, err := common.NewAssetPairFromStr(liquidateResp.PositionResp.Position.Pair) + pair, err := common.NewAssetPair(liquidateResp.PositionResp.Position.Pair) if err != nil { return err } @@ -270,7 +270,7 @@ func (k Keeper) ExecutePartialLiquidation( ) (types.LiquidateResp, error) { params := k.GetParams(ctx) - pair, err := common.NewAssetPairFromStr(currentPosition.Pair) + pair, err := common.NewAssetPair(currentPosition.Pair) if err != nil { return types.LiquidateResp{}, err } diff --git a/x/perp/keeper/liquidate_test.go b/x/perp/keeper/liquidate_test.go index ab8400246..22aee3a07 100644 --- a/x/perp/keeper/liquidate_test.go +++ b/x/perp/keeper/liquidate_test.go @@ -11,9 +11,9 @@ import ( "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/perp/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" testutilevents "github.com/NibiruChain/nibiru/x/testutil/events" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestExecuteFullLiquidation_EmptyPosition(t *testing.T) { @@ -49,8 +49,8 @@ func TestExecuteFullLiquidation_EmptyPosition(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) - pair, err2 := common.NewAssetPairFromStr("BTC:NUSD") + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) + pair, err2 := common.NewAssetPair("BTC:NUSD") require.NoError(t, err2) t.Log("Set vpool defined by pair on VpoolKeeper") @@ -127,7 +127,7 @@ func TestExecuteFullLiquidation_EmptyPosition(t *testing.T) { func TestExecuteFullLiquidation(t *testing.T) { // constants for this suite - tokenPair, err := common.NewAssetPairFromStr("BTC:NUSD") + tokenPair, err := common.NewAssetPair("BTC:NUSD") require.NoError(t, err) traderAddr := sample.AccAddress() @@ -229,7 +229,7 @@ func TestExecuteFullLiquidation(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) perpKeeper := &nibiruApp.PerpKeeper t.Log("create vpool") @@ -363,8 +363,8 @@ func TestExecutePartialLiquidation_EmptyPosition(t *testing.T) { tc := tc t.Run(tc.name, func(t *testing.T) { t.Log("Initialize keepers, pair, and liquidator") - nibiruApp, ctx := testutilapp.NewNibiruApp(true) - pair, err := common.NewAssetPairFromStr("xxx:yyy") + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) + pair, err := common.NewAssetPair("xxx:yyy") require.NoError(t, err) vpoolKeeper := &nibiruApp.VpoolKeeper perpKeeper := &nibiruApp.PerpKeeper @@ -428,7 +428,7 @@ func TestExecutePartialLiquidation_EmptyPosition(t *testing.T) { func TestExecutePartialLiquidation(t *testing.T) { // constants for this suite - tokenPair, err := common.NewAssetPairFromStr("xxx:yyy") + tokenPair, err := common.NewAssetPair("xxx:yyy") require.NoError(t, err) traderAddr := sample.AccAddress() @@ -502,7 +502,7 @@ func TestExecutePartialLiquidation(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) t.Log("Set vpool defined by pair on VpoolKeeper") vpoolKeeper := &nibiruApp.VpoolKeeper diff --git a/x/perp/keeper/margin.go b/x/perp/keeper/margin.go index 57ea43a67..451b18b37 100644 --- a/x/perp/keeper/margin.go +++ b/x/perp/keeper/margin.go @@ -37,7 +37,7 @@ func (k Keeper) AddMargin( } // validate token pair - pair, err := common.NewAssetPairFromStr(msg.TokenPair) + pair, err := common.NewAssetPair(msg.TokenPair) if err != nil { k.Logger(ctx).Debug( err.Error(), @@ -155,7 +155,7 @@ func (k Keeper) RemoveMargin( } // validate token pair - pair, err := common.NewAssetPairFromStr(msg.TokenPair) + pair, err := common.NewAssetPair(msg.TokenPair) if err != nil { k.Logger(ctx).Debug( err.Error(), diff --git a/x/perp/keeper/margin_test.go b/x/perp/keeper/margin_test.go index 66d5874b0..2669a1b9a 100644 --- a/x/perp/keeper/margin_test.go +++ b/x/perp/keeper/margin_test.go @@ -11,9 +11,9 @@ import ( "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/perp/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" testutilevents "github.com/NibiruChain/nibiru/x/testutil/events" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestOpenPosition_Setup(t *testing.T) { @@ -25,8 +25,8 @@ func TestOpenPosition_Setup(t *testing.T) { name: "open pos - uninitialized pool raised pair not supported error", test: func() { t.Log("Setup Nibiru app, pair, and trader without a vpool.") - nibiruApp, ctx := testutilapp.NewNibiruApp(true) - pair, err := common.NewAssetPairFromStr("xxx:yyy") + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) + pair, err := common.NewAssetPair("xxx:yyy") require.NoError(t, err) trader := sample.AccAddress() @@ -46,8 +46,8 @@ func TestOpenPosition_Setup(t *testing.T) { name: "open pos - vpool not set on the perp PairMetadata ", test: func() { t.Log("Setup Nibiru app, pair, and trader") - nibiruApp, ctx := testutilapp.NewNibiruApp(true) - pair, err := common.NewAssetPairFromStr("xxx:yyy") + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) + pair, err := common.NewAssetPair("xxx:yyy") require.NoError(t, err) t.Log("Set vpool defined by pair on VpoolKeeper") @@ -81,8 +81,8 @@ func TestOpenPosition_Setup(t *testing.T) { name: "open pos - happy path 1", test: func() { t.Log("Setup Nibiru app, pair, and trader") - nibiruApp, ctx := testutilapp.NewNibiruApp(true) - pair, err := common.NewAssetPairFromStr("xxx:yyy") + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) + pair, err := common.NewAssetPair("xxx:yyy") require.NoError(t, err) t.Log("Set vpool defined by pair on VpoolKeeper") @@ -142,25 +142,25 @@ func TestAddMarginError(t *testing.T) { { name: "msg denom differs from pair quote asset", test: func() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) t.Log("Set vpool defined by pair on VpoolKeeper") vpoolKeeper := &nibiruApp.VpoolKeeper vpoolKeeper.CreatePool( ctx, - /* pair */ common.PAIR_uBTC_uNUSD, + /* pair */ common.PairBTCStable, /* tradeLimitRatio */ sdk.MustNewDecFromStr("0.9"), /* quoteReserves */ sdk.NewDec(10_000_000), // /* baseReserves */ sdk.NewDec(5_000_000), // 5 tokens /* fluctuationLimitRatio */ sdk.MustNewDecFromStr("0.1"), /* maxOracleSpreadRatio */ sdk.OneDec(), ) - require.True(t, vpoolKeeper.ExistsPool(ctx, common.PAIR_uBTC_uNUSD)) + require.True(t, vpoolKeeper.ExistsPool(ctx, common.PairBTCStable)) t.Log("create msg for MsgAddMargin with invalid denom") msg := &types.MsgAddMargin{ Sender: sample.AccAddress().String(), - TokenPair: common.PAIR_uBTC_uNUSD.String(), + TokenPair: common.PairBTCStable.String(), Margin: sdk.NewCoin("notADenom", sdk.NewInt(400)), } @@ -172,25 +172,25 @@ func TestAddMarginError(t *testing.T) { { name: "invalid sender", test: func() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) t.Log("create vpool") vpoolKeeper := &nibiruApp.VpoolKeeper vpoolKeeper.CreatePool( ctx, - /* pair */ common.PAIR_uBTC_uNUSD, + /* pair */ common.PairBTCStable, /* tradeLimitRatio */ sdk.MustNewDecFromStr("0.9"), /* quoteReserves */ sdk.NewDec(10_000_000), // /* baseReserves */ sdk.NewDec(5_000_000), // 5 tokens /* fluctuationLimitRatio */ sdk.MustNewDecFromStr("0.1"), /* maxOracleSpreadRatio */ sdk.OneDec(), ) - require.True(t, vpoolKeeper.ExistsPool(ctx, common.PAIR_uBTC_uNUSD)) + require.True(t, vpoolKeeper.ExistsPool(ctx, common.PairBTCStable)) t.Log("create msg for MsgAddMargin with invalid denom") msg := &types.MsgAddMargin{ Sender: "", - TokenPair: common.PAIR_uBTC_uNUSD.String(), + TokenPair: common.PairBTCStable.String(), Margin: sdk.NewCoin("unusd", sdk.NewInt(400)), } @@ -202,25 +202,25 @@ func TestAddMarginError(t *testing.T) { { name: "invalid negative margin add", test: func() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) t.Log("create vpool") vpoolKeeper := &nibiruApp.VpoolKeeper vpoolKeeper.CreatePool( ctx, - /* pair */ common.PAIR_uBTC_uNUSD, + /* pair */ common.PairBTCStable, /* tradeLimitRatio */ sdk.MustNewDecFromStr("0.9"), /* quoteReserves */ sdk.NewDec(10_000_000), // /* baseReserves */ sdk.NewDec(5_000_000), // 5 tokens /* fluctuationLimitRatio */ sdk.MustNewDecFromStr("0.1"), /* maxOracleSpreadRatio */ sdk.OneDec(), ) - require.True(t, vpoolKeeper.ExistsPool(ctx, common.PAIR_uBTC_uNUSD)) + require.True(t, vpoolKeeper.ExistsPool(ctx, common.PairBTCStable)) t.Log("create msg for MsgAddMargin with invalid denom") msg := &types.MsgAddMargin{ Sender: sample.AccAddress().String(), - TokenPair: common.PAIR_uBTC_uNUSD.String(), + TokenPair: common.PairBTCStable.String(), Margin: sdk.Coin{Denom: "unusd", Amount: sdk.NewInt(-400)}, } @@ -255,7 +255,7 @@ func TestAddMarginSuccess(t *testing.T) { latestCumulativePremiumFraction: sdk.MustNewDecFromStr("0.001"), initialPosition: types.Position{ TraderAddress: sample.AccAddress().String(), - Pair: common.PAIR_uBTC_uNUSD.String(), + Pair: common.PairBTCStable.String(), Size_: sdk.NewDec(1_000), Margin: sdk.NewDec(100), OpenNotional: sdk.NewDec(500), @@ -271,7 +271,7 @@ func TestAddMarginSuccess(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) traderAddr, err := sdk.AccAddressFromBech32(tc.initialPosition.TraderAddress) require.NoError(t, err) @@ -282,7 +282,7 @@ func TestAddMarginSuccess(t *testing.T) { ctx, traderAddr, sdk.NewCoins( - sdk.NewCoin(common.PAIR_uBTC_uNUSD.GetQuoteTokenDenom(), tc.marginToAdd), + sdk.NewCoin(common.PairBTCStable.GetQuoteTokenDenom(), tc.marginToAdd), ), ) require.NoErrorf(t, err, "fund account call should work") @@ -291,20 +291,20 @@ func TestAddMarginSuccess(t *testing.T) { vpoolKeeper := &nibiruApp.VpoolKeeper vpoolKeeper.CreatePool( ctx, - common.PAIR_uBTC_uNUSD, + common.PairBTCStable, sdk.MustNewDecFromStr("0.9"), // 0.9 ratio sdk.NewDec(10_000_000), // sdk.NewDec(5_000_000), // 5 tokens sdk.MustNewDecFromStr("0.1"), // 0.9 ratio /* maxOracleSpreadRatio */ sdk.MustNewDecFromStr("1.0"), // 100% ) - require.True(t, vpoolKeeper.ExistsPool(ctx, common.PAIR_uBTC_uNUSD)) + require.True(t, vpoolKeeper.ExistsPool(ctx, common.PairBTCStable)) t.Log("set pair metadata") perpKeeper := &nibiruApp.PerpKeeper perpKeeper.PairMetadataState(ctx).Set( &types.PairMetadata{ - Pair: common.PAIR_uBTC_uNUSD.String(), + Pair: common.PairBTCStable.String(), CumulativePremiumFractions: []sdk.Dec{ tc.latestCumulativePremiumFraction, }, @@ -314,7 +314,7 @@ func TestAddMarginSuccess(t *testing.T) { t.Log("establish initial position") nibiruApp.PerpKeeper.SetPosition( ctx, - common.PAIR_uBTC_uNUSD, + common.PairBTCStable, traderAddr, &tc.initialPosition, ) @@ -324,7 +324,7 @@ func TestAddMarginSuccess(t *testing.T) { Sender: traderAddr.String(), TokenPair: tc.initialPosition.Pair, Margin: sdk.Coin{ - Denom: common.PAIR_uBTC_uNUSD.GetQuoteTokenDenom(), + Denom: common.PairBTCStable.GetQuoteTokenDenom(), Amount: tc.marginToAdd, }, } @@ -335,7 +335,7 @@ func TestAddMarginSuccess(t *testing.T) { assert.EqualValues(t, tc.initialPosition.OpenNotional, resp.Position.OpenNotional) assert.EqualValues(t, tc.initialPosition.Size_, resp.Position.Size_) assert.EqualValues(t, traderAddr.String(), resp.Position.TraderAddress) - assert.EqualValues(t, common.PAIR_uBTC_uNUSD.String(), resp.Position.Pair) + assert.EqualValues(t, common.PairBTCStable.String(), resp.Position.Pair) assert.EqualValues(t, tc.latestCumulativePremiumFraction, resp.Position.LastUpdateCumulativePremiumFraction) assert.EqualValues(t, ctx.BlockHeight(), resp.Position.BlockNumber) }) @@ -352,15 +352,15 @@ func TestRemoveMargin(t *testing.T) { test: func() { removeAmt := sdk.NewInt(-5) - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) trader := sample.AccAddress() - pair, err := common.NewAssetPairFromStr("osmo:nusd") + pair, err := common.NewAssetPair("osmo:nusd") require.NoError(t, err) goCtx := sdk.WrapSDKContext(ctx) msg := &types.MsgRemoveMargin{ Sender: trader.String(), TokenPair: pair.String(), - Margin: sdk.Coin{Denom: common.StableDenom, Amount: removeAmt}} + Margin: sdk.Coin{Denom: common.DenomStable, Amount: removeAmt}} _, err = nibiruApp.PerpKeeper.RemoveMargin(goCtx, msg) require.Error(t, err) require.ErrorContains(t, err, "margin must be positive") @@ -369,9 +369,9 @@ func TestRemoveMargin(t *testing.T) { { name: "zero margin remove - fail", test: func() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) trader := sample.AccAddress() - pair, err := common.NewAssetPairFromStr("osmo:nusd") + pair, err := common.NewAssetPair("osmo:nusd") require.NoError(t, err) goCtx := sdk.WrapSDKContext(ctx) @@ -379,7 +379,7 @@ func TestRemoveMargin(t *testing.T) { Sender: trader.String(), TokenPair: pair.String(), Margin: sdk.Coin{ - Denom: common.StableDenom, + Denom: common.DenomStable, Amount: sdk.ZeroInt(), }, } @@ -393,15 +393,15 @@ func TestRemoveMargin(t *testing.T) { test: func() { removeAmt := sdk.NewInt(5) - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) trader := sample.AccAddress() - pair, err := common.NewAssetPairFromStr("osmo:nusd") + pair, err := common.NewAssetPair("osmo:nusd") require.NoError(t, err) goCtx := sdk.WrapSDKContext(ctx) msg := &types.MsgRemoveMargin{ Sender: trader.String(), TokenPair: pair.String(), - Margin: sdk.Coin{Denom: common.StableDenom, Amount: removeAmt}} + Margin: sdk.Coin{Denom: common.DenomStable, Amount: removeAmt}} _, err = nibiruApp.PerpKeeper.RemoveMargin(goCtx, msg) require.Error(t, err) require.ErrorContains(t, err, types.ErrPairNotFound.Error()) @@ -411,9 +411,9 @@ func TestRemoveMargin(t *testing.T) { name: "pool exists but trader doesn't have position - fail", test: func() { t.Log("Setup Nibiru app, pair, and trader") - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) trader := sample.AccAddress() - pair, err := common.NewAssetPairFromStr("osmo:nusd") + pair, err := common.NewAssetPair("osmo:nusd") require.NoError(t, err) t.Log("Setup vpool defined by pair") @@ -444,9 +444,9 @@ func TestRemoveMargin(t *testing.T) { name: "remove margin from healthy position - fast integration test 1", test: func() { t.Log("Setup Nibiru app, pair, and trader") - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) traderAddr := sample.AccAddress() - pair, err := common.NewAssetPairFromStr("xxx:yyy") + pair, err := common.NewAssetPair("xxx:yyy") require.NoError(t, err) t.Log("Set vpool defined by pair on VpoolKeeper") diff --git a/x/perp/keeper/margin_unit_test.go b/x/perp/keeper/margin_unit_test.go index 170c2e75c..9debfd01f 100644 --- a/x/perp/keeper/margin_unit_test.go +++ b/x/perp/keeper/margin_unit_test.go @@ -201,7 +201,7 @@ func TestRemoveMargin(t *testing.T) { msg := &types.MsgRemoveMargin{ Sender: trader.String(), TokenPair: the3pool, - Margin: sdk.NewCoin(common.StableDenom, sdk.NewInt(5))} + Margin: sdk.NewCoin(common.DenomStable, sdk.NewInt(5))} _, err := k.RemoveMargin(goCtx, msg) require.Error(t, err) require.ErrorContains(t, err, common.ErrInvalidTokenPair.Error()) @@ -265,7 +265,7 @@ func TestRemoveMargin(t *testing.T) { Margin: sdk.NewCoin("nusd", sdk.NewInt(100)), } - pair, err := common.NewAssetPairFromStr(msg.TokenPair) + pair, err := common.NewAssetPair(msg.TokenPair) require.NoError(t, err) mocks.mockVpoolKeeper.EXPECT().ExistsPool(ctx, pair). AnyTimes().Return(true) @@ -334,7 +334,7 @@ func TestRemoveMargin(t *testing.T) { Margin: sdk.NewCoin("nusd", sdk.NewInt(100)), } - pair, err := common.NewAssetPairFromStr(msg.TokenPair) + pair, err := common.NewAssetPair(msg.TokenPair) require.NoError(t, err) mocks.mockVpoolKeeper.EXPECT().ExistsPool(ctx, pair). AnyTimes().Return(true) @@ -437,7 +437,7 @@ func TestAddMargin(t *testing.T) { msg := &types.MsgAddMargin{ Sender: trader.String(), TokenPair: the3pool, - Margin: sdk.NewInt64Coin(common.StableDenom, 5), + Margin: sdk.NewInt64Coin(common.DenomStable, 5), } _, err := k.AddMargin(goCtx, msg) require.ErrorContains(t, err, common.ErrInvalidTokenPair.Error()) @@ -500,7 +500,7 @@ func TestAddMargin(t *testing.T) { perpKeeper, mocks, ctx := getKeeper(t) goCtx := sdk.WrapSDKContext(ctx) - assetPair, err := common.NewAssetPairFromStr("uosmo:unusd") + assetPair, err := common.NewAssetPair("uosmo:unusd") require.NoError(t, err) traderAddr := sample.AccAddress() @@ -568,7 +568,7 @@ func TestAddMargin(t *testing.T) { test: func() { perpKeeper, mocks, ctx := getKeeper(t) - assetPair, err := common.NewAssetPairFromStr("uosmo:unusd") + assetPair, err := common.NewAssetPair("uosmo:unusd") require.NoError(t, err) traderAddr := sample.AccAddress() diff --git a/x/perp/keeper/msg_server.go b/x/perp/keeper/msg_server.go index 4634c32aa..a86ef7537 100644 --- a/x/perp/keeper/msg_server.go +++ b/x/perp/keeper/msg_server.go @@ -35,7 +35,7 @@ func (k msgServer) AddMargin(ctx context.Context, margin *types.MsgAddMargin, func (k msgServer) OpenPosition(goCtx context.Context, req *types.MsgOpenPosition, ) (response *types.MsgOpenPositionResponse, err error) { - pair, err := common.NewAssetPairFromStr(req.TokenPair) + pair, err := common.NewAssetPair(req.TokenPair) if err != nil { panic(err) // must not happen } @@ -68,7 +68,7 @@ func (k msgServer) ClosePosition(goCtx context.Context, position *types.MsgClose panic(err) } - tokenPair, err := common.NewAssetPairFromStr(position.TokenPair) + tokenPair, err := common.NewAssetPair(position.TokenPair) if err != nil { panic(err) } diff --git a/x/perp/keeper/perp.go b/x/perp/keeper/perp.go index 88bbd0671..a44523b20 100644 --- a/x/perp/keeper/perp.go +++ b/x/perp/keeper/perp.go @@ -30,7 +30,7 @@ func (k Keeper) SettlePosition( currentPosition types.Position, ) (transferredCoins sdk.Coins, err error) { // Validate token pair - tokenPair, err := common.NewAssetPairFromStr(currentPosition.Pair) + tokenPair, err := common.NewAssetPair(currentPosition.Pair) if err != nil { return sdk.Coins{}, err } diff --git a/x/perp/keeper/perp_test.go b/x/perp/keeper/perp_test.go index 115ccd2f8..8aed0a40d 100644 --- a/x/perp/keeper/perp_test.go +++ b/x/perp/keeper/perp_test.go @@ -11,8 +11,8 @@ import ( "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/perp/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" "github.com/stretchr/testify/require" ) @@ -26,8 +26,8 @@ func TestGetAndSetPosition(t *testing.T) { name: "get - no positions set raises vpool not found error", test: func() { trader := sample.AccAddress() - nibiruApp, ctx := testutilapp.NewNibiruApp(true) - pair, err := common.NewAssetPairFromStr("osmo:nusd") + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) + pair, err := common.NewAssetPair("osmo:nusd") require.NoError(t, err) _, err = nibiruApp.PerpKeeper.GetPosition( @@ -39,11 +39,11 @@ func TestGetAndSetPosition(t *testing.T) { { name: "set - creating position with set works and shows up in get", test: func() { - vpoolPair, err := common.NewAssetPairFromStr("osmo:nusd") + vpoolPair, err := common.NewAssetPair("osmo:nusd") require.NoError(t, err) traderAddr := sample.AccAddress() - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) _, err = nibiruApp.PerpKeeper.GetPosition( ctx, vpoolPair, traderAddr) @@ -82,13 +82,13 @@ func TestClearPosition(t *testing.T) { { name: "set - creating position with set works and shows up in get", test: func() { - vpoolPair, err := common.NewAssetPairFromStr("osmo:nusd") + vpoolPair, err := common.NewAssetPair("osmo:nusd") require.NoError(t, err) traders := []sdk.AccAddress{ sample.AccAddress(), sample.AccAddress(), } - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) t.Log("vpool contains no positions to start") for _, trader := range traders { @@ -161,8 +161,8 @@ func TestKeeper_ClosePosition(t *testing.T) { // TODO(mercilex): simulate funding payments t.Run("success", func(t *testing.T) { t.Log("Setup Nibiru app, pair, and trader") - nibiruApp, ctx := testutilapp.NewNibiruApp(true) - pair, err := common.NewAssetPairFromStr("xxx:yyy") + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) + pair, err := common.NewAssetPair("xxx:yyy") require.NoError(t, err) t.Log("Set vpool defined by pair on VpoolKeeper") diff --git a/x/perp/keeper/perp_unit_test.go b/x/perp/keeper/perp_unit_test.go index 090ae5d64..5c801b81e 100644 --- a/x/perp/keeper/perp_unit_test.go +++ b/x/perp/keeper/perp_unit_test.go @@ -16,7 +16,7 @@ func TestSettlePosition(t *testing.T) { t.Run("success - settlement price zero", func(t *testing.T) { k, dep, ctx := getKeeper(t) traderAddr := sample.AccAddress() - pair, err := common.NewAssetPairFromStr("LUNA:UST") + pair, err := common.NewAssetPair("LUNA:UST") require.NoError(t, err) dep.mockVpoolKeeper. @@ -52,7 +52,7 @@ func TestSettlePosition(t *testing.T) { t.Run("success - settlement price not zero", func(t *testing.T) { k, dep, ctx := getKeeper(t) traderAddr := sample.AccAddress() - pair, err := common.NewAssetPairFromStr("LUNA:UST") // memeing + pair, err := common.NewAssetPair("LUNA:UST") // memeing require.NoError(t, err) dep.mockVpoolKeeper. @@ -94,7 +94,7 @@ func TestSettlePosition(t *testing.T) { t.Run("position size is zero", func(t *testing.T) { k, _, ctx := getKeeper(t) traderAddr := sample.AccAddress() - pair, err := common.NewAssetPairFromStr("LUNA:UST") + pair, err := common.NewAssetPair("LUNA:UST") require.NoError(t, err) pos := types.Position{ diff --git a/x/perp/module_test.go b/x/perp/module_test.go index 63c24f639..156ef8b86 100644 --- a/x/perp/module_test.go +++ b/x/perp/module_test.go @@ -6,13 +6,13 @@ import ( "github.com/stretchr/testify/assert" "github.com/NibiruChain/nibiru/x/perp/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) // TestModuleAccounts verifies that all x/perp module accounts are connected // to the base application func TestModuleAccounts(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) perpAcc := nibiruApp.PerpKeeper.AccountKeeper.GetModuleAccount( ctx, types.ModuleName) diff --git a/x/perp/spec/01_concepts.md b/x/perp/spec/01_concepts.md index 6b1326e06..cbbf8d058 100644 --- a/x/perp/spec/01_concepts.md +++ b/x/perp/spec/01_concepts.md @@ -29,15 +29,24 @@ The **mark price** is the value of the derivative asset (the perp) on the exchan The value of a perp's underlying asset is referred to as the **index price**. For example, a BTC:USD perp has BTC as its **base asset** and dollar collateral such as USDC as could be its **quote asset**. The dollar value of BTC on spot exchanges is the index price of the BTC:USD perp. Thus we'd call BTC **"the underlying"**. Usually, the index price is taken as the average of spot prices across major exchanges. ## Leverage and Perp Position Value + #### Position Size Suppose a trader wanted exposure to 5 ETH through the purchase of a perpetual contract. On Nibi-Perps, going long on 5 ETH means that the trader buys the ETH perp with a **position size** of 5. Position size is computed as the position notional mutlipled by the mark price of the asset. +```go +k = baseReserves * quoteReserves +notionalDelta = margin * leverage // (leverage is negative if short) +baseReservesAfterSwap = k / (quoteReserves + notionalDelta) +position_size = baseReserves - baseReservesAfterSwap +``` + #### Position Notional Value The notional value of the position, or **position notional**, is the total value a position controls in units of the quote asset. Notional value expresses the value a derivatives contract theoretically controls. On Nibiru, it is defined more concretely by -``` +```go +positionNotional = abs(quoteReserves - k/(baseReserves + position_size)) leverage = positionNotional / margin. ``` diff --git a/x/perp/types/expected_keepers.go b/x/perp/types/expected_keepers.go index 6b0e19145..2635a8508 100644 --- a/x/perp/types/expected_keepers.go +++ b/x/perp/types/expected_keepers.go @@ -53,12 +53,12 @@ type PricefeedKeeper interface { ) (pftypes.CurrentPrice, error) GetCurrentPrices(ctx sdk.Context) pftypes.CurrentPrices GetRawPrices(ctx sdk.Context, marketId string) pftypes.PostedPrices - GetPair(ctx sdk.Context, pairID string) (pftypes.Pair, bool) + IsActivePair(ctx sdk.Context, pairID string) bool // Returns the pairs from the x/pricefeed params - GetPairs(ctx sdk.Context) pftypes.Pairs - GetOracle(ctx sdk.Context, pairID string, address sdk.AccAddress, - ) (sdk.AccAddress, error) - GetOracles(ctx sdk.Context, pairID string) ([]sdk.AccAddress, error) + GetPairs(ctx sdk.Context) common.AssetPairs + IsWhitelistedOracle(ctx sdk.Context, pairID string, address sdk.AccAddress, + ) bool + GetOraclesForPair(ctx sdk.Context, pairID string) (oracles []sdk.AccAddress) SetCurrentPrices(ctx sdk.Context, token0 string, token1 string) error GetCurrentTWAPPrice(ctx sdk.Context, token0 string, token1 string) (pftypes.CurrentTWAP, error) } @@ -239,7 +239,7 @@ type VpoolKeeper interface { GetSettlementPrice(ctx sdk.Context, pair common.AssetPair) (sdk.Dec, error) // GetCurrentTWAPPrice fetches the TWAP for the specified token pair / pool - GetCurrentTWAPPrice(ctx sdk.Context, token0 string, token1 string) (vpooltypes.CurrentTWAP, error) + GetCurrentTWAPPrice(ctx sdk.Context, pair common.AssetPair) (vpooltypes.CurrentTWAP, error) } type EpochKeeper interface { diff --git a/x/perp/types/expected_keepers_test.go b/x/perp/types/expected_keepers_test.go index 9cd3cf6c3..fb149a53e 100644 --- a/x/perp/types/expected_keepers_test.go +++ b/x/perp/types/expected_keepers_test.go @@ -7,7 +7,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/NibiruChain/nibiru/x/perp/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) /* TestExpectedKeepers verifies that the expected keeper interfaces in x/perp @@ -15,7 +15,7 @@ import ( 'NibiruApp.KeeperName' */ func TestExpectedKeepers(t *testing.T) { - nibiruApp, _ := testutilapp.NewNibiruApp(true) + nibiruApp, _ := testapp.NewNibiruAppAndContext(true) testCases := []struct { name string expectedKeeper interface{} diff --git a/x/perp/types/msgs.go b/x/perp/types/msgs.go index 8d8ba6089..01a4cd2d2 100644 --- a/x/perp/types/msgs.go +++ b/x/perp/types/msgs.go @@ -63,7 +63,7 @@ func (msg *MsgOpenPosition) ValidateBasic() error { if msg.Side != Side_SELL && msg.Side != Side_BUY { return fmt.Errorf("invalid side") } - if _, err := common.NewAssetPairFromStr(msg.TokenPair); err != nil { + if _, err := common.NewAssetPair(msg.TokenPair); err != nil { return err } if _, err := sdk.AccAddressFromBech32(msg.Sender); err != nil { @@ -102,7 +102,7 @@ func (msg MsgLiquidate) ValidateBasic() (err error) { if _, err = sdk.AccAddressFromBech32(msg.Trader); err != nil { return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid trader address (%s)", err) } - if _, err := common.NewAssetPairFromStr(msg.TokenPair); err != nil { + if _, err := common.NewAssetPair(msg.TokenPair); err != nil { return err } return nil @@ -130,7 +130,7 @@ func (msg MsgClosePosition) ValidateBasic() error { if err != nil { return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid sender address (%s)", err) } - if _, err := common.NewAssetPairFromStr(msg.TokenPair); err != nil { + if _, err := common.NewAssetPair(msg.TokenPair); err != nil { return err } return nil diff --git a/x/perp/types/state.go b/x/perp/types/state.go index f01b3c348..c840cfb47 100644 --- a/x/perp/types/state.go +++ b/x/perp/types/state.go @@ -3,7 +3,7 @@ package types import "github.com/NibiruChain/nibiru/x/common" func (p *Position) GetAssetPair() common.AssetPair { - pair, err := common.NewAssetPairFromStr(p.Pair) + pair, err := common.NewAssetPair(p.Pair) if err != nil { panic(err) } diff --git a/x/pricefeed/abci.go b/x/pricefeed/abci.go index 5d531dc07..e40268e64 100644 --- a/x/pricefeed/abci.go +++ b/x/pricefeed/abci.go @@ -13,7 +13,7 @@ import ( func BeginBlocker(ctx sdk.Context, k keeper.Keeper) { // Update the current price of each asset. for _, pair := range k.GetPairs(ctx) { - if !pair.Active { + if !k.IsActivePair(ctx, pair.String()) { continue } diff --git a/x/pricefeed/abci_test.go b/x/pricefeed/abci_test.go index 926ddb9b6..c7bf7513f 100644 --- a/x/pricefeed/abci_test.go +++ b/x/pricefeed/abci_test.go @@ -11,8 +11,8 @@ import ( "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/pricefeed" ptypes "github.com/NibiruChain/nibiru/x/pricefeed/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestTWAPriceUpdates(t *testing.T) { @@ -20,7 +20,11 @@ func TestTWAPriceUpdates(t *testing.T) { var ctx sdk.Context oracle := sample.AccAddress() - token0, token1 := common.StableDenom, common.CollDenom + pair := common.AssetPair{ + Token0: common.DenomColl, + Token1: common.DenomStable, + } + runBlock := func(duration time.Duration) { ctx = ctx. WithBlockHeight(ctx.BlockHeight() + 1). @@ -29,25 +33,20 @@ func TestTWAPriceUpdates(t *testing.T) { } setPrice := func(price string) { _, err := nibiruApp.PricefeedKeeper.SetPrice( - ctx, oracle, token0, token1, + ctx, oracle, pair.String(), sdk.MustNewDecFromStr(price), ctx.BlockTime().Add(time.Hour*5000*4)) require.NoError(t, err) } - nibiruApp, ctx = testutilapp.NewNibiruApp(true) + nibiruApp, ctx = testapp.NewNibiruAppAndContext(true) ctx = ctx.WithBlockTime(time.Date(2015, 10, 21, 0, 0, 0, 0, time.UTC)) - markets := ptypes.NewParams([]ptypes.Pair{ - { - Token0: token0, - Token1: token1, - Oracles: []sdk.AccAddress{oracle}, - Active: true, - }, - }) - - nibiruApp.PricefeedKeeper.SetParams(ctx, markets) + oracles := []sdk.AccAddress{oracle} + pairs := common.AssetPairs{pair} + params := ptypes.NewParams(pairs) + nibiruApp.PricefeedKeeper.SetParams(ctx, params) // makes pairs active + nibiruApp.PricefeedKeeper.WhitelistOraclesForPairs(ctx, oracles, pairs) // Sim set price set the price for one hour setPrice("0.9") @@ -55,7 +54,7 @@ func TestTWAPriceUpdates(t *testing.T) { err := nibiruApp.StablecoinKeeper.SetCollRatio(ctx, sdk.MustNewDecFromStr("0.8")) require.NoError(t, err) - // Pass 5000 hours, previous price is alive and we post a new one + t.Log("Pass 5000 hours. Previous price is live and we post a new one") runBlock(time.Hour * 5000) setPrice("0.8") runBlock(time.Hour * 5000) @@ -68,13 +67,15 @@ func TestTWAPriceUpdates(t *testing.T) { (0.9 * 1463385600 + (0.9 + 0.8) / 2 * 1481385600) / (1463385600 + 1481385600) = 0.8749844622444971 */ - price, err := nibiruApp.PricefeedKeeper.GetCurrentTWAPPrice(ctx, token0, token1) + + price, err := nibiruApp.PricefeedKeeper.GetCurrentTWAPPrice( + ctx, pair.Token0, pair.Token1) require.NoError(t, err) priceFloat, err := price.Price.Float64() require.NoError(t, err) require.InDelta(t, 0.8748471867695528, priceFloat, 0.03) - // 5000 hours passed, both previous price is alive and we post a new one + t.Log("5000 hours passed, both previous prices are live and we post a new one") setPrice("0.82") runBlock(time.Hour * 5000) @@ -87,7 +88,8 @@ func TestTWAPriceUpdates(t *testing.T) { (0.9 * 1463385600 + (0.9 + 0.8) / 2 * 1481385600 + 0.82 * 1499385600) / (1463385600 + 1481385600 + 1499385600) = 0.8563426456960295 */ - price, err = nibiruApp.PricefeedKeeper.GetCurrentTWAPPrice(ctx, token0, token1) + price, err = nibiruApp.PricefeedKeeper.GetCurrentTWAPPrice( + ctx, pair.Token0, pair.Token1) require.NoError(t, err) priceFloat, err = price.Price.Float64() require.NoError(t, err) @@ -106,7 +108,8 @@ func TestTWAPriceUpdates(t *testing.T) { */ setPrice("0.83") runBlock(time.Hour * 5000) - price, err = nibiruApp.PricefeedKeeper.GetCurrentTWAPPrice(ctx, token0, token1) + price, err = nibiruApp.PricefeedKeeper.GetCurrentTWAPPrice( + ctx, pair.Token0, pair.Token1) require.NoError(t, err) priceFloat, err = price.Price.Float64() diff --git a/x/pricefeed/client/cli/cli_test.go b/x/pricefeed/client/cli/cli_test.go index 8da7c6eb9..110c055d6 100644 --- a/x/pricefeed/client/cli/cli_test.go +++ b/x/pricefeed/client/cli/cli_test.go @@ -9,64 +9,67 @@ import ( "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/crypto/hd" "github.com/cosmos/cosmos-sdk/crypto/keyring" - clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli" + sdktestutilcli "github.com/cosmos/cosmos-sdk/testutil/cli" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/gogo/protobuf/proto" "github.com/stretchr/testify/suite" + tmcli "github.com/tendermint/tendermint/libs/cli" "github.com/NibiruChain/nibiru/app" "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/pricefeed/client/cli" - pftypes "github.com/NibiruChain/nibiru/x/pricefeed/types" + pricefeedtypes "github.com/NibiruChain/nibiru/x/pricefeed/types" testutilcli "github.com/NibiruChain/nibiru/x/testutil/cli" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) const ( - oracleAddress = "nibi1zuxt7fvuxgj69mjxu3auca96zemqef5u2yemly" - oracleMnemonic = "kit soon capital dry sadness balance rival embark behind coast online struggle deer crush hospital during man monkey prison action custom wink utility arrive" + genOracleAddress = "nibi1zuxt7fvuxgj69mjxu3auca96zemqef5u2yemly" + genOracleMnemonic = "kit soon capital dry sadness balance rival embark behind coast online struggle deer crush hospital during man monkey prison action custom wink utility arrive" ) type IntegrationTestSuite struct { suite.Suite - cfg testutilcli.Config - network *testutilcli.Network + cfg testutilcli.Config + network *testutilcli.Network + oracleUIDs []string + oracleMap map[string]sdk.AccAddress } -// NewPricefeedGen returns an x/pricefeed GenesisState to specify the module parameters. -func NewPricefeedGen() *pftypes.GenesisState { - oracle, _ := sdk.AccAddressFromBech32(oracleAddress) - - return &pftypes.GenesisState{ - Params: pftypes.Params{ - Pairs: []pftypes.Pair{ - { - Token0: common.GovStablePool.Token0, - Token1: common.GovStablePool.Token1, - Oracles: []sdk.AccAddress{oracle}, Active: true, - }, - { - Token0: common.CollStablePool.Token0, - Token1: common.CollStablePool.Token1, - Oracles: []sdk.AccAddress{oracle}, Active: true, - }, - }, - }, - PostedPrices: []pftypes.PostedPrice{ - { - PairID: common.GovStablePool.PairID(), - OracleAddress: oracle, - Price: sdk.NewDec(10), - Expiry: time.Now().Add(1 * time.Hour), - }, - { - PairID: common.CollStablePool.PairID(), - OracleAddress: oracle, - Price: sdk.OneDec(), - Expiry: time.Now().Add(1 * time.Hour), - }, - }, +func (s *IntegrationTestSuite) setupOraclesForKeyring() { + val := s.network.Validators[0] + s.oracleUIDs = []string{"oracle", "wrongOracle"} + + for _, oracleUID := range s.oracleUIDs { + info, _, err := val.ClientCtx.Keyring.NewMnemonic( + /* uid */ oracleUID, + /* language */ keyring.English, + /* hdPath */ sdk.FullFundraiserPath, + /* bip39Passphrase */ "", + /* algo */ hd.Secp256k1) + s.oracleMap[oracleUID] = sdk.AccAddress(info.GetPubKey().Address()) + s.Require().NoError(err) } + + info, err := val.ClientCtx.Keyring.NewAccount( + /* uid */ "genOracle", + /* mnemonic */ genOracleMnemonic, + /* bip39Passphrase */ "", + /* hdPath */ sdk.FullFundraiserPath, + /* algo */ hd.Secp256k1, + ) + s.oracleMap["genOracle"] = sdk.AccAddress(info.GetPubKey().Address()) + s.Require().NoError(err) + + _, _, err = val.ClientCtx.Keyring.NewMnemonic( + /* uid */ "oracle", + /* language */ keyring.English, + /* hdPath */ sdk.FullFundraiserPath, + /* bip39Passphrase */ "", + /* algo */ hd.Secp256k1) + s.Require().Error(err) + s.Require().ErrorContains(err, "public key already exists in keybase") } func (s *IntegrationTestSuite) SetupSuite() { @@ -81,21 +84,27 @@ func (s *IntegrationTestSuite) SetupSuite() { s.T().Log("setting up integration test suite") - s.cfg = testutilcli.DefaultConfig() - - // modification to pay fee with test bond denom "stake" app.SetPrefixes(app.AccountAddressPrefix) - genesisState := app.ModuleBasics.DefaultGenesis(s.cfg.Codec) - pricefeedGenJson := s.cfg.Codec.MustMarshalJSON(NewPricefeedGen()) - genesisState[pftypes.ModuleName] = pricefeedGenJson + encCfg := app.MakeTestEncodingConfig() + defaultAppGenesis := app.ModuleBasics.DefaultGenesis(encCfg.Marshaler) + testAppGenesis := testapp.NewTestGenesisState(encCfg.Marshaler, defaultAppGenesis) + s.cfg = testutilcli.BuildNetworkConfig(testAppGenesis) - s.cfg.GenesisState = genesisState + s.network = testutilcli.NewNetwork(s.T(), s.cfg) - s.network = testutilcli.New(s.T(), s.cfg) + s.oracleMap = make(map[string]sdk.AccAddress) + s.setupOraclesForKeyring() _, err := s.network.WaitForHeight(1) s.Require().NoError(err) + + res, err := testutilcli.QueryPrice( + s.network.Validators[0].ClientCtx, + common.PairGovStable.String(), + ) + s.Require().NoError(err) + s.Assert().Equal(sdk.NewDec(10), res.Price.Price) } func (s *IntegrationTestSuite) TearDownSuite() { @@ -104,8 +113,6 @@ func (s *IntegrationTestSuite) TearDownSuite() { } func (s IntegrationTestSuite) TestGetPriceCmd() { - val := s.network.Validators[0] - testCases := []struct { name string args []string @@ -117,18 +124,18 @@ func (s IntegrationTestSuite) TestGetPriceCmd() { { name: "Get default price of collateral token", args: []string{ - common.CollStablePool.PairID(), + common.PairCollStable.String(), }, expectedPrice: sdk.NewDec(1), - respType: &pftypes.QueryPriceResponse{}, + respType: &pricefeedtypes.QueryPriceResponse{}, }, { name: "Get default price of governance token", args: []string{ - common.GovStablePool.PairID(), + common.PairGovStable.String(), }, expectedPrice: sdk.NewDec(10), - respType: &pftypes.QueryPriceResponse{}, + respType: &pricefeedtypes.QueryPriceResponse{}, }, { name: "Invalid pair returns an error", @@ -136,7 +143,7 @@ func (s IntegrationTestSuite) TestGetPriceCmd() { "invalid:pair", }, expectErr: true, - respType: &pftypes.QueryPriceResponse{}, + respType: &pricefeedtypes.QueryPriceResponse{}, }, } @@ -145,28 +152,25 @@ func (s IntegrationTestSuite) TestGetPriceCmd() { s.Run(tc.name, func() { cmd := cli.CmdPrice() - clientCtx := val.ClientCtx.WithOutputFormat("json") + queryResp := new(pricefeedtypes.QueryPriceResponse) + err := testutilcli.ExecQuery( + s.network, cmd, + append(tc.args, fmt.Sprintf("--%s=json", tmcli.OutputFlag)), + queryResp, + ) - out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, tc.args) if tc.expectErr { s.Require().Error(err) } else { - s.Require().NoError(err, out.String()) - s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), tc.respType), out.String()) - - txResp := tc.respType.(*pftypes.QueryPriceResponse) - err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), txResp) s.Require().NoError(err) - s.Assert().Equal(tc.expectedPrice, txResp.Price.Price) - s.Assert().Equal(tc.args[0], txResp.Price.PairID) + s.Assert().Equal(tc.expectedPrice, queryResp.Price.Price) + s.Assert().Equal(tc.args[0], queryResp.Price.PairID) } }) } } func (s IntegrationTestSuite) TestGetRawPricesCmd() { - val := s.network.Validators[0] - testCases := []struct { name string args []string @@ -179,18 +183,18 @@ func (s IntegrationTestSuite) TestGetRawPricesCmd() { { name: "Get default price of collateral token", args: []string{ - common.CollStablePool.PairID(), + common.PairCollStable.String(), }, expectedPrice: sdk.NewDec(1), - respType: &pftypes.QueryRawPricesResponse{}, + respType: &pricefeedtypes.QueryRawPricesResponse{}, }, { name: "Get default price of governance token", args: []string{ - common.GovStablePool.PairID(), + common.PairGovStable.String(), }, expectedPrice: sdk.NewDec(10), - respType: &pftypes.QueryRawPricesResponse{}, + respType: &pricefeedtypes.QueryRawPricesResponse{}, }, { name: "Invalid pair returns an error", @@ -199,7 +203,7 @@ func (s IntegrationTestSuite) TestGetRawPricesCmd() { }, expectedPrice: sdk.NewDec(10), expectErr: true, - respType: &pftypes.QueryRawPricesResponse{}, + respType: &pricefeedtypes.QueryRawPricesResponse{}, }, } @@ -208,23 +212,22 @@ func (s IntegrationTestSuite) TestGetRawPricesCmd() { s.Run(tc.name, func() { cmd := cli.CmdRawPrices() - clientCtx := val.ClientCtx.WithOutputFormat("json") + queryResp := new(pricefeedtypes.QueryRawPricesResponse) + err := testutilcli.ExecQuery( + s.network, cmd, + append(tc.args, fmt.Sprintf("--%s=json", tmcli.OutputFlag)), + queryResp, + ) - out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, tc.args) if tc.expectErr { s.Require().Error(err) } else { - s.Require().NoError(err, out.String()) - s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), tc.respType), out.String()) - - txResp := tc.respType.(*pftypes.QueryRawPricesResponse) - err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), txResp) s.Require().NoError(err) - s.Require().Equal(len(txResp.RawPrices), 1) - s.Assert().Equal(tc.expectedPrice, txResp.RawPrices[0].Price) - s.Assert().Equal(oracleAddress, txResp.RawPrices[0].OracleAddress) + s.Require().Equal(len(queryResp.RawPrices), 1) + s.Assert().Equal(tc.expectedPrice, queryResp.RawPrices[0].Price) + s.Assert().Equal(genOracleAddress, queryResp.RawPrices[0].OracleAddress) // The initial prices are valid for one hour - s.Assert().True(expireWithinHours(txResp.RawPrices[0].GetExpiry(), 1)) + s.Assert().True(expireWithinHours(queryResp.RawPrices[0].GetExpiry(), 1)) } }) } @@ -237,21 +240,22 @@ func expireWithinHours(t time.Time, hours time.Duration) bool { func (s IntegrationTestSuite) TestPairsCmd() { val := s.network.Validators[0] - gov, col := common.GovStablePool, common.CollStablePool - oracle, _ := sdk.AccAddressFromBech32(oracleAddress) + oracle, _ := sdk.AccAddressFromBech32(genOracleAddress) testCases := []struct { name string - expectedPairs pftypes.PairResponses + expectedPairs pricefeedtypes.PairResponses respType proto.Message }{ { name: "Get current pairs", - expectedPairs: pftypes.PairResponses{ - pftypes.NewPairResponse(gov.Token1, gov.Token0, []sdk.AccAddress{oracle}, true), - pftypes.NewPairResponse(col.Token1, col.Token0, []sdk.AccAddress{oracle}, true), + expectedPairs: pricefeedtypes.PairResponses{ + pricefeedtypes.NewPairResponse(common.PairGovStable, []sdk.AccAddress{oracle}, true), + pricefeedtypes.NewPairResponse(common.PairCollStable, []sdk.AccAddress{oracle}, true), + pricefeedtypes.NewPairResponse(common.PairBTCStable, []sdk.AccAddress{oracle}, true), + pricefeedtypes.NewPairResponse(common.PairETHStable, []sdk.AccAddress{oracle}, true), }, - respType: &pftypes.QueryPairsResponse{}, + respType: &pricefeedtypes.QueryPairsResponse{}, }, } @@ -262,11 +266,11 @@ func (s IntegrationTestSuite) TestPairsCmd() { cmd := cli.CmdPairs() clientCtx := val.ClientCtx.WithOutputFormat("json") - out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, nil) + out, err := sdktestutilcli.ExecTestCLICmd(clientCtx, cmd, nil) s.Require().NoError(err, out.String()) s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), tc.respType), out.String()) - txResp := tc.respType.(*pftypes.QueryPairsResponse) + txResp := tc.respType.(*pricefeedtypes.QueryPairsResponse) err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), txResp) s.Require().NoError(err) s.Assert().Equal(len(tc.expectedPairs), len(txResp.Pairs)) @@ -283,16 +287,16 @@ func (s IntegrationTestSuite) TestPricesCmd() { testCases := []struct { name string - expectedPricePairs []pftypes.CurrentPriceResponse + expectedPricePairs []pricefeedtypes.CurrentPriceResponse respType proto.Message }{ { name: "Get current prices", - expectedPricePairs: []pftypes.CurrentPriceResponse{ - pftypes.NewCurrentPriceResponse(common.GovStablePool.PairID(), sdk.NewDec(10)), - pftypes.NewCurrentPriceResponse(common.CollStablePool.PairID(), sdk.NewDec(1)), + expectedPricePairs: []pricefeedtypes.CurrentPriceResponse{ + pricefeedtypes.NewCurrentPriceResponse(common.PairGovStable.String(), sdk.NewDec(10)), + pricefeedtypes.NewCurrentPriceResponse(common.PairCollStable.String(), sdk.NewDec(1)), }, - respType: &pftypes.QueryPricesResponse{}, + respType: &pricefeedtypes.QueryPricesResponse{}, }, } @@ -303,17 +307,17 @@ func (s IntegrationTestSuite) TestPricesCmd() { cmd := cli.CmdPrices() clientCtx := val.ClientCtx.WithOutputFormat("json") - out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, nil) + out, err := sdktestutilcli.ExecTestCLICmd(clientCtx, cmd, nil) s.Require().NoError(err, out.String()) s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), tc.respType), out.String()) - txResp := tc.respType.(*pftypes.QueryPricesResponse) + txResp := tc.respType.(*pricefeedtypes.QueryPricesResponse) err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), txResp) s.Require().NoError(err) s.Assert().Equal(len(tc.expectedPricePairs), len(txResp.Prices)) - for _, pp := range txResp.Prices { - s.Assert().Contains(tc.expectedPricePairs, pp) + for _, priceResponse := range txResp.Prices { + s.Assert().Contains(tc.expectedPricePairs, priceResponse, tc.expectedPricePairs) } }) } @@ -333,26 +337,27 @@ func (s IntegrationTestSuite) TestOraclesCmd() { { name: "Get the collateral oracles", args: []string{ - common.CollStablePool.PairID(), + common.PairCollStable.String(), }, - expectedOracles: []string{oracleAddress}, - respType: &pftypes.QueryOraclesResponse{}, + expectedOracles: []string{genOracleAddress}, + respType: &pricefeedtypes.QueryOraclesResponse{}, }, { name: "Get the governance oracles", args: []string{ - common.GovStablePool.PairID(), + common.PairGovStable.String(), }, - expectedOracles: []string{oracleAddress}, - respType: &pftypes.QueryOraclesResponse{}, + expectedOracles: []string{genOracleAddress}, + respType: &pricefeedtypes.QueryOraclesResponse{}, }, { name: "Invalid pair returns an error", args: []string{ "invalid:pair", }, - expectErr: true, - respType: &pftypes.QueryOraclesResponse{}, + expectErr: false, + expectedOracles: []string{}, + respType: &pricefeedtypes.QueryOraclesResponse{}, }, } @@ -363,14 +368,14 @@ func (s IntegrationTestSuite) TestOraclesCmd() { cmd := cli.CmdOracles() clientCtx := val.ClientCtx.WithOutputFormat("json") - out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, tc.args) + out, err := sdktestutilcli.ExecTestCLICmd(clientCtx, cmd, tc.args) if tc.expectErr { - s.Require().Error(err) + s.Require().Error(err, out.String()) } else { s.Require().NoError(err, out.String()) s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), tc.respType), out.String()) - txResp := tc.respType.(*pftypes.QueryOraclesResponse) + txResp := tc.respType.(*pricefeedtypes.QueryOraclesResponse) err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), txResp) s.Require().NoError(err) s.Assert().Equal(tc.expectedOracles, txResp.Oracles) @@ -379,30 +384,29 @@ func (s IntegrationTestSuite) TestOraclesCmd() { } } func (s IntegrationTestSuite) TestSetPriceCmd() { + err := s.network.WaitForNextBlock() + s.Require().NoError(err) + val := s.network.Validators[0] - gov, col := common.GovStablePool, common.CollStablePool + gov, col := common.PairGovStable, common.PairCollStable now := time.Now() - expireInOneHour, expiredTS := strconv.Itoa(int(now.Add(1*time.Hour).Unix())), strconv.Itoa(int(now.Add(-1*time.Hour).Unix())) - _, err := val.ClientCtx.Keyring.NewAccount( - /* uid */ "oracle", - /* mnemonic */ oracleMnemonic, - /* bip39Passphrase */ "", - /* hdPath */ sdk.FullFundraiserPath, - /* algo */ hd.Secp256k1, - ) - s.Require().NoError(err) - info, _, err := val.ClientCtx.Keyring.NewMnemonic("wrongOracle", keyring.English, sdk.FullFundraiserPath, "", hd.Secp256k1) - s.Require().NoError(err) - wrongOracleAddress := sdk.AccAddress(info.GetPubKey().Address()) - oracle, _ := sdk.AccAddressFromBech32(oracleAddress) - gasFeeToken := sdk.NewCoins(sdk.NewInt64Coin("stake", 100_000_000)) - _, err = testutilcli.FillWalletFromValidator(wrongOracleAddress, gasFeeToken, val, s.cfg.BondDenom) - s.Require().NoError(err) - _, err = testutilcli.FillWalletFromValidator(oracle, gasFeeToken, val, s.cfg.BondDenom) - s.Require().NoError(err) + expireInOneHour := strconv.Itoa(int(now.Add(1 * time.Hour).Unix())) + expiredTS := strconv.Itoa(int(now.Add(-1 * time.Hour).Unix())) + + gasFeeToken := sdk.NewCoins(sdk.NewInt64Coin(s.cfg.BondDenom, 1_000_000)) + for _, oracleName := range []string{"genOracle", "wrongOracle"} { + _, err = testutilcli.FillWalletFromValidator( + /*addr=*/ s.oracleMap[oracleName], + /*balanece=*/ gasFeeToken, + /*Validator=*/ val, + /*feesDenom=*/ s.cfg.BondDenom) + s.Require().NoError(err) + } + commonArgs := []string{ fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation), + fmt.Sprintf("--%s=test", flags.FlagKeyringBackend), fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock), fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10))).String()), } @@ -420,18 +424,20 @@ func (s IntegrationTestSuite) TestSetPriceCmd() { args: []string{ gov.Token0, gov.Token1, "100", expireInOneHour, }, - expectedPriceForPair: map[string]sdk.Dec{gov.PairID(): sdk.NewDec(100)}, - respType: &sdk.TxResponse{}, - fromOracle: "oracle", + expectedPriceForPair: map[string]sdk.Dec{ + gov.String(): sdk.NewDec(100)}, + respType: &sdk.TxResponse{}, + fromOracle: "genOracle", }, { name: "Set the price of the collateral token", args: []string{ - col.Token0, col.Token1, "0.5", expireInOneHour, + col.Token0, col.Token1, "0.85", expireInOneHour, }, - expectedPriceForPair: map[string]sdk.Dec{col.PairID(): sdk.NewDec(2)}, - respType: &sdk.TxResponse{}, - fromOracle: "oracle", + expectedPriceForPair: map[string]sdk.Dec{ + col.String(): sdk.MustNewDecFromStr("0.85")}, + respType: &sdk.TxResponse{}, + fromOracle: "genOracle", }, { name: "Use invalid oracle", @@ -447,9 +453,9 @@ func (s IntegrationTestSuite) TestSetPriceCmd() { args: []string{ "invalid", "pair", "123", expireInOneHour, }, - expectedCode: 5, + expectedCode: 6, respType: &sdk.TxResponse{}, - fromOracle: "oracle", + fromOracle: "genOracle", }, { name: "Set expired pair returns an error", @@ -458,7 +464,7 @@ func (s IntegrationTestSuite) TestSetPriceCmd() { }, expectedCode: 3, respType: &sdk.TxResponse{}, - fromOracle: "oracle", + fromOracle: "genOracle", }, } @@ -469,15 +475,16 @@ func (s IntegrationTestSuite) TestSetPriceCmd() { cmd := cli.CmdPostPrice() clientCtx := val.ClientCtx - commonArgs = append(commonArgs, fmt.Sprintf("--%s=%s", flags.FlagFrom, tc.fromOracle)) - out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, append(tc.args, commonArgs...)) - s.Require().NoError(err, out.String()) - s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), tc.respType), out.String()) + commonArgs = append(commonArgs, + fmt.Sprintf("--%s=%s", flags.FlagFrom, s.oracleMap[tc.fromOracle])) + out, err := sdktestutilcli.ExecTestCLICmd(clientCtx, cmd, append(tc.args, commonArgs...)) + s.Require().NoError(err) + s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), tc.respType)) txResp := tc.respType.(*sdk.TxResponse) err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), txResp) s.Require().NoError(err) - s.Assert().Equal(tc.expectedCode, txResp.Code, out.String()) + s.Assert().Equal(tc.expectedCode, txResp.Code) for pairID, price := range tc.expectedPriceForPair { currentPrice, err := testutilcli.QueryRawPrice(clientCtx, pairID) @@ -499,16 +506,22 @@ func (s IntegrationTestSuite) TestSetPriceCmd() { func (s IntegrationTestSuite) TestGetParamsCmd() { val := s.network.Validators[0] + var pricefeedGenState pricefeedtypes.GenesisState + s.cfg.Codec.MustUnmarshalJSON( + s.cfg.GenesisState[pricefeedtypes.ModuleName], + &pricefeedGenState, + ) + testCases := []struct { name string respType proto.Message - expectedParams pftypes.Params + expectedParams pricefeedtypes.Params }{ { name: "Get all params", - respType: &pftypes.QueryParamsResponse{}, - expectedParams: NewPricefeedGen().Params, + respType: &pricefeedtypes.QueryParamsResponse{}, + expectedParams: pricefeedGenState.Params, }, } @@ -519,11 +532,11 @@ func (s IntegrationTestSuite) TestGetParamsCmd() { cmd := cli.CmdQueryParams() clientCtx := val.ClientCtx.WithOutputFormat("json") - out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, nil) + out, err := sdktestutilcli.ExecTestCLICmd(clientCtx, cmd, nil) s.Require().NoError(err, out.String()) s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), tc.respType), out.String()) - txResp := tc.respType.(*pftypes.QueryParamsResponse) + txResp := tc.respType.(*pricefeedtypes.QueryParamsResponse) err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), txResp) s.Require().NoError(err) s.Assert().Equal(tc.expectedParams, txResp.Params) diff --git a/x/pricefeed/client/cli/query.go b/x/pricefeed/client/cli/query.go index 597a86825..0ca434542 100644 --- a/x/pricefeed/client/cli/query.go +++ b/x/pricefeed/client/cli/query.go @@ -48,14 +48,14 @@ func CmdPrice() *cobra.Command { queryClient := types.NewQueryClient(clientCtx) - pair, err := common.NewAssetPairFromStr(args[0]) + pair, err := common.NewAssetPair(args[0]) if err != nil { return fmt.Errorf("invalid pair: %w", err) } - params := &types.QueryPriceRequest{PairId: pair.String()} + request := &types.QueryPriceRequest{PairId: pair.String()} - res, err := queryClient.Price(cmd.Context(), params) + res, err := queryClient.QueryPrice(cmd.Context(), request) if err != nil { return err } @@ -82,9 +82,9 @@ func CmdPrices() *cobra.Command { queryClient := types.NewQueryClient(clientCtx) - params := &types.QueryPricesRequest{} + request := &types.QueryPricesRequest{} - res, err := queryClient.Prices(cmd.Context(), params) + res, err := queryClient.QueryPrices(cmd.Context(), request) if err != nil { return err } @@ -111,9 +111,9 @@ func CmdPairs() *cobra.Command { queryClient := types.NewQueryClient(clientCtx) - params := &types.QueryPairsRequest{} + request := &types.QueryPairsRequest{} - res, err := queryClient.Pairs(cmd.Context(), params) + res, err := queryClient.QueryPairs(cmd.Context(), request) if err != nil { return err } @@ -140,14 +140,14 @@ func CmdOracles() *cobra.Command { queryClient := types.NewQueryClient(clientCtx) - pair, err := common.NewAssetPairFromStr(args[0]) + pair, err := common.NewAssetPair(args[0]) if err != nil { return fmt.Errorf("invalid pair: %w", err) } - params := &types.QueryOraclesRequest{PairId: pair.String()} + request := &types.QueryOraclesRequest{PairId: pair.String()} - res, err := queryClient.Oracles(cmd.Context(), params) + res, err := queryClient.QueryOracles(cmd.Context(), request) if err != nil { return err } @@ -174,7 +174,7 @@ func CmdQueryParams() *cobra.Command { queryClient := types.NewQueryClient(clientCtx) - res, err := queryClient.Params(cmd.Context(), &types.QueryParamsRequest{}) + res, err := queryClient.QueryParams(cmd.Context(), &types.QueryParamsRequest{}) if err != nil { return err } @@ -201,11 +201,16 @@ func CmdRawPrices() *cobra.Command { queryClient := types.NewQueryClient(clientCtx) - params := &types.QueryRawPricesRequest{ + _, err = common.NewAssetPair(args[0]) + if err != nil { + return err + } + + req := &types.QueryRawPricesRequest{ PairId: args[0], } - res, err := queryClient.RawPrices(cmd.Context(), params) + res, err := queryClient.QueryRawPrices(cmd.Context(), req) if err != nil { return err } diff --git a/x/pricefeed/client/cli/tx.go b/x/pricefeed/client/cli/tx.go index fe5970075..28b604fb2 100644 --- a/x/pricefeed/client/cli/tx.go +++ b/x/pricefeed/client/cli/tx.go @@ -7,7 +7,7 @@ import ( "github.com/spf13/cobra" "github.com/cosmos/cosmos-sdk/client" - // "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/NibiruChain/nibiru/x/pricefeed/types" ) @@ -17,7 +17,7 @@ var ( // GetTxCmd returns the transaction commands for this module func GetTxCmd() *cobra.Command { - cmd := &cobra.Command{ + txCmd := &cobra.Command{ Use: types.ModuleName, Short: fmt.Sprintf("%s transactions subcommands", types.ModuleName), DisableFlagParsing: true, @@ -25,8 +25,9 @@ func GetTxCmd() *cobra.Command { RunE: client.ValidateCmd, } - cmd.AddCommand(CmdPostPrice()) - // this line is used by starport scaffolding # 1 + txCmd.AddCommand( + CmdPostPrice(), + ) - return cmd + return txCmd } diff --git a/x/pricefeed/genesis.go b/x/pricefeed/genesis.go index a5afd0d2d..00358f759 100644 --- a/x/pricefeed/genesis.go +++ b/x/pricefeed/genesis.go @@ -1,10 +1,11 @@ package pricefeed import ( - "strings" + "fmt" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/pricefeed/keeper" "github.com/NibiruChain/nibiru/x/pricefeed/types" ) @@ -12,33 +13,36 @@ import ( // InitGenesis initializes the capability module's state from a provided genesis // state. func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState) { - // this line is used by starport scaffolding # genesis/module/init k.SetParams(ctx, genState.Params) + k.ActivePairsStore(). + AddActivePairs(ctx, genState.Params.Pairs) + k.WhitelistOracles(ctx, common.StringsToAddrs(genState.GenesisOracles...)) - // Iterate through the posted prices and set them in the store if they are not expired + // If posted prices are not expired, set them in the store for _, pp := range genState.PostedPrices { if pp.Expiry.After(ctx.BlockTime()) { - tokens := strings.Split(pp.PairID, ":") - token0, token1 := tokens[0], tokens[1] - _, err := k.SetPrice(ctx, pp.OracleAddress, token0, token1, pp.Price, pp.Expiry) + oracle := sdk.MustAccAddressFromBech32(pp.Oracle) + _, err := k.SetPrice(ctx, oracle, pp.PairID, pp.Price, pp.Expiry) if err != nil { panic(err) } + } else { + panic(fmt.Errorf("failed to post prices for pair %v", pp.PairID)) } } params := k.GetParams(ctx) // Set the current price (if any) based on what's now in the store - for _, market := range params.Pairs { - if !market.Active { + for _, pair := range params.Pairs { + if !k.ActivePairsStore().Get(ctx, pair) { continue } - rps := k.GetRawPrices(ctx, market.PairID()) + postedPrices := k.GetRawPrices(ctx, pair.String()) - if len(rps) == 0 { + if len(postedPrices) == 0 { continue } - err := k.SetCurrentPrices(ctx, market.Token0, market.Token1) + err := k.SetCurrentPrices(ctx, pair.Token0, pair.Token1) if err != nil { panic(err) } @@ -50,8 +54,8 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState { genesis := types.DefaultGenesis() genesis.Params = k.GetParams(ctx) var postedPrices []types.PostedPrice - for _, market := range k.GetPairs(ctx) { - pp := k.GetRawPrices(ctx, market.PairID()) + for _, assetPair := range k.GetPairs(ctx) { + pp := k.GetRawPrices(ctx, assetPair.String()) postedPrices = append(postedPrices, pp...) } genesis.PostedPrices = postedPrices diff --git a/x/pricefeed/genesis_test.go b/x/pricefeed/genesis_test.go index e8866c9f3..bf7856a11 100644 --- a/x/pricefeed/genesis_test.go +++ b/x/pricefeed/genesis_test.go @@ -1,17 +1,29 @@ package pricefeed_test import ( + "fmt" "testing" + "time" + tmtypes "github.com/tendermint/tendermint/types" + + "github.com/NibiruChain/nibiru/x/common" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + tmproto "github.com/tendermint/tendermint/proto/tendermint/types" + + "github.com/NibiruChain/nibiru/app" "github.com/NibiruChain/nibiru/x/pricefeed" "github.com/NibiruChain/nibiru/x/pricefeed/types" testutilkeeper "github.com/NibiruChain/nibiru/x/testutil/keeper" "github.com/NibiruChain/nibiru/x/testutil/nullify" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) -func TestGenesis(t *testing.T) { +func TestGenesis_DefaultGenesis(t *testing.T) { genesisState := types.GenesisState{ Params: types.DefaultParams(), } @@ -21,6 +33,106 @@ func TestGenesis(t *testing.T) { got := pricefeed.ExportGenesis(ctx, k) require.NotNil(t, got) + assert.EqualValues(t, types.DefaultPairs, got.Params.Pairs) + assert.Empty(t, got.GenesisOracles) + assert.Empty(t, got.PostedPrices) + nullify.Fill(&genesisState) nullify.Fill(got) + + require.Equal(t, genesisState, *got) +} + +func TestGenesis_TestGenesis(t *testing.T) { + app.SetPrefixes(app.AccountAddressPrefix) + appGenesis := testapp.NewTestGenesisStateFromDefault() + pfGenesisState := testapp.PricefeedGenesis() + + nibiruApp := testapp.NewNibiruAppWithGenesis(appGenesis) + ctx := nibiruApp.NewContext(false, tmproto.Header{}) + k := nibiruApp.PricefeedKeeper + pricefeed.InitGenesis(ctx, k, pfGenesisState) + params := k.GetParams(ctx) + assert.Equal(t, pfGenesisState.Params, params) + + // genOracle should be whitelisted on all pairs + for _, pair := range params.Pairs { + assert.True(t, k.IsWhitelistedOracle( + ctx, pair.String(), sdk.MustAccAddressFromBech32(pfGenesisState.GenesisOracles[0]))) + } + + // prices are only posted for PairGovStable and PairCollStable + assert.NotEmpty(t, k.GetRawPrices(ctx, params.Pairs[0].String())) + assert.NotEmpty(t, k.GetRawPrices(ctx, params.Pairs[1].String())) +} + +func TestGenesisState_Validate(t *testing.T) { + mockPrivKey := tmtypes.NewMockPV() + pubkey, err := mockPrivKey.GetPubKey() + require.NoError(t, err) + addr := sdk.AccAddress(pubkey.Address()) + now := time.Now() + + examplePairs := common.NewAssetPairs("xrp:bnb") + for _, tc := range []struct { + desc string + genState *types.GenesisState + err error + }{ + { + desc: "default is valid", + genState: types.DefaultGenesis(), + err: nil, + }, + { + desc: "valid genesis state - empty", + genState: &types.GenesisState{}, + err: nil, + }, + { + desc: "valid genesis state - full", + genState: types.NewGenesisState( + types.NewParams( + /*pairs=*/ examplePairs, + ), + []types.PostedPrice{ + types.NewPostedPrice(examplePairs[0], addr, sdk.OneDec(), now)}, + ), + err: nil, + }, + { + desc: "invalid posted price - pair must be in genesis params", + genState: types.NewGenesisState( + types.NewParams( + /*pairs=*/ common.AssetPairs{}, + ), + []types.PostedPrice{ + types.NewPostedPrice(examplePairs[0], addr, sdk.OneDec(), now)}, + ), + err: fmt.Errorf("must be in the genesis params"), + }, + { + desc: "duplicated posted price at same timestamp - invalid", + genState: types.NewGenesisState( + types.NewParams( + /*pairs=*/ common.AssetPairs{}, + ), + []types.PostedPrice{ + types.NewPostedPrice(examplePairs[0], addr, sdk.OneDec(), now), + types.NewPostedPrice(examplePairs[0], addr, sdk.OneDec(), now), + }, + ), + err: fmt.Errorf("duplicated posted price"), + }, + } { + t.Run(tc.desc, func(t *testing.T) { + err := tc.genState.Validate() + if tc.err != nil { + require.Error(t, err) + assert.ErrorContains(t, err, tc.err.Error()) + } else { + require.NoError(t, err) + } + }) + } } diff --git a/x/pricefeed/handler.go b/x/pricefeed/handler.go index e3ba17570..76cb1a54b 100644 --- a/x/pricefeed/handler.go +++ b/x/pricefeed/handler.go @@ -21,7 +21,6 @@ func NewHandler(k keeper.Keeper) sdk.Handler { case *types.MsgPostPrice: res, err := msgServer.PostPrice(sdk.WrapSDKContext(ctx), msg) return sdk.WrapServiceResult(ctx, res, err) - // this line is used by starport scaffolding # 1 default: errMsg := fmt.Sprintf("unrecognized %s message type: %T", types.ModuleName, msg) return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg) diff --git a/x/pricefeed/keeper/grpc_query.go b/x/pricefeed/keeper/grpc_query.go index be3bd3817..457f0139f 100644 --- a/x/pricefeed/keeper/grpc_query.go +++ b/x/pricefeed/keeper/grpc_query.go @@ -1,7 +1,157 @@ package keeper import ( + "context" + + sdk "github.com/cosmos/cosmos-sdk/types" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/pricefeed/types" ) var _ types.QueryServer = Keeper{} + +func (k Keeper) QueryPrice(goCtx context.Context, req *types.QueryPriceRequest) (*types.QueryPriceResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + ctx := sdk.UnwrapSDKContext(goCtx) + + pair, err := common.NewAssetPair(req.PairId) + if err != nil { + return nil, err + } + if !k.GetPairs(ctx).Contains(pair) { + return nil, status.Error(codes.NotFound, "pair not in module params") + } + if !k.ActivePairsStore().getKV(ctx).Has([]byte(pair.String())) { + return nil, status.Error(codes.NotFound, "invalid market ID") + } + + tokens := common.DenomsFromPoolName(req.PairId) + token0, token1 := tokens[0], tokens[1] + currentPrice, sdkErr := k.GetCurrentPrice(ctx, token0, token1) + if sdkErr != nil { + return nil, sdkErr + } + + return &types.QueryPriceResponse{ + Price: types.CurrentPriceResponse{PairID: req.PairId, Price: currentPrice.Price}, + }, nil +} + +func (k Keeper) QueryRawPrices( + goCtx context.Context, req *types.QueryRawPricesRequest, +) (*types.QueryRawPricesResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + ctx := sdk.UnwrapSDKContext(goCtx) + + if !k.IsActivePair(ctx, req.PairId) { + return nil, status.Error(codes.NotFound, "invalid market ID") + } + + var prices types.PostedPriceResponses + for _, rp := range k.GetRawPrices(ctx, req.PairId) { + prices = append(prices, types.PostedPriceResponse{ + PairID: rp.PairID, + OracleAddress: rp.Oracle, + Price: rp.Price, + Expiry: rp.Expiry, + }) + } + + return &types.QueryRawPricesResponse{ + RawPrices: prices, + }, nil +} + +func (k Keeper) QueryPrices(goCtx context.Context, req *types.QueryPricesRequest) (*types.QueryPricesResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + ctx := sdk.UnwrapSDKContext(goCtx) + + var currentPrices types.CurrentPriceResponses + for _, currentPrice := range k.GetCurrentPrices(ctx) { + if currentPrice.PairID != "" { + currentPrices = append(currentPrices, types.CurrentPriceResponse(currentPrice)) + } + } + + return &types.QueryPricesResponse{ + Prices: currentPrices, + }, nil +} + +func (k Keeper) QueryOracles(goCtx context.Context, req *types.QueryOraclesRequest) (*types.QueryOraclesResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + ctx := sdk.UnwrapSDKContext(goCtx) + + _, err := common.NewAssetPair(req.PairId) + if err != nil { + return nil, status.Error(codes.NotFound, "invalid market ID") + } + + oracles := k.GetOraclesForPair(ctx, req.PairId) + if len(oracles) == 0 { + return &types.QueryOraclesResponse{}, nil + } + + var strOracles []string + for _, oracle := range oracles { + strOracles = append(strOracles, oracle.String()) + } + + return &types.QueryOraclesResponse{ + Oracles: strOracles, + }, nil +} + +func (k Keeper) QueryParams(c context.Context, req *types.QueryParamsRequest) (*types.QueryParamsResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + ctx := sdk.UnwrapSDKContext(c) + + return &types.QueryParamsResponse{Params: k.GetParams(ctx)}, nil +} + +func (k Keeper) QueryPairs(goCtx context.Context, req *types.QueryPairsRequest, +) (*types.QueryPairsResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + ctx := sdk.UnwrapSDKContext(goCtx) + + var responses types.PairResponses + for _, pair := range k.GetParams(ctx).Pairs { + var oracleStrings []string + for _, oracle := range k.OraclesStore().Get(ctx, pair) { + oracleStrings = append(oracleStrings, oracle.String()) + } + + responses = append(responses, types.PairResponse{ + PairID: pair.String(), + Token0: pair.Token0, + Token1: pair.Token1, + Oracles: oracleStrings, + Active: k.IsActivePair(ctx, pair.String()), + }) + } + + // TODO improve these variable names. PairResponse is confusing on field "Pairs" + return &types.QueryPairsResponse{ + Pairs: responses, + }, nil +} diff --git a/x/pricefeed/keeper/grpc_query_markets.go b/x/pricefeed/keeper/grpc_query_markets.go deleted file mode 100644 index f3b04328f..000000000 --- a/x/pricefeed/keeper/grpc_query_markets.go +++ /dev/null @@ -1,28 +0,0 @@ -package keeper - -import ( - "context" - - sdk "github.com/cosmos/cosmos-sdk/types" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" - - "github.com/NibiruChain/nibiru/x/pricefeed/types" -) - -func (k Keeper) Pairs(goCtx context.Context, req *types.QueryPairsRequest) (*types.QueryPairsResponse, error) { - if req == nil { - return nil, status.Error(codes.InvalidArgument, "invalid request") - } - - ctx := sdk.UnwrapSDKContext(goCtx) - - var markets types.PairResponses - for _, market := range k.GetPairs(ctx) { - markets = append(markets, market.ToPairResponse()) - } - - return &types.QueryPairsResponse{ - Pairs: markets, - }, nil -} diff --git a/x/pricefeed/keeper/grpc_query_markets_test.go b/x/pricefeed/keeper/grpc_query_markets_test.go deleted file mode 100644 index b3d2d7df0..000000000 --- a/x/pricefeed/keeper/grpc_query_markets_test.go +++ /dev/null @@ -1,37 +0,0 @@ -package keeper_test - -import ( - "testing" - - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/stretchr/testify/require" - - "github.com/NibiruChain/nibiru/x/pricefeed/types" - testkeeper "github.com/NibiruChain/nibiru/x/testutil/keeper" -) - -func TestMarketsQuery(t *testing.T) { - keeper, ctx := testkeeper.PricefeedKeeper(t) - wctx := sdk.WrapSDKContext(ctx) - params := types.Params{ - Pairs: []types.Pair{ - {Token0: "btc", Token1: "usd", Oracles: nil, Active: true}, - {Token0: "xrp", Token1: "usd", Oracles: nil, Active: true}, - {Token0: "ada", Token1: "usd", Oracles: []sdk.AccAddress{[]byte("some oracle address")}, Active: true}, - {Token0: "eth", Token1: "usd", Oracles: []sdk.AccAddress{[]byte("random oracle address")}, Active: false}, - }, - } - keeper.SetParams(ctx, params) - - response, err := keeper.Pairs(wctx, &types.QueryPairsRequest{}) - require.NoError(t, err) - require.Equal(t, &types.QueryPairsResponse{Pairs: pairToPairResponse(params.Pairs)}, response) -} - -func pairToPairResponse(pairs []types.Pair) []types.PairResponse { - r := []types.PairResponse{} - for _, p := range pairs { - r = append(r, types.NewPairResponse(p.Token1, p.Token0, p.Oracles, p.Active)) - } - return r -} diff --git a/x/pricefeed/keeper/grpc_query_oracles.go b/x/pricefeed/keeper/grpc_query_oracles.go deleted file mode 100644 index ae649274f..000000000 --- a/x/pricefeed/keeper/grpc_query_oracles.go +++ /dev/null @@ -1,33 +0,0 @@ -package keeper - -import ( - "context" - - sdk "github.com/cosmos/cosmos-sdk/types" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" - - "github.com/NibiruChain/nibiru/x/pricefeed/types" -) - -func (k Keeper) Oracles(goCtx context.Context, req *types.QueryOraclesRequest) (*types.QueryOraclesResponse, error) { - if req == nil { - return nil, status.Error(codes.InvalidArgument, "invalid request") - } - - ctx := sdk.UnwrapSDKContext(goCtx) - - oracles, err := k.GetOracles(ctx, req.PairId) - if err != nil { - return nil, status.Error(codes.NotFound, "invalid market ID") - } - - var strOracles []string - for _, oracle := range oracles { - strOracles = append(strOracles, oracle.String()) - } - - return &types.QueryOraclesResponse{ - Oracles: strOracles, - }, nil -} diff --git a/x/pricefeed/keeper/grpc_query_oracles_test.go b/x/pricefeed/keeper/grpc_query_oracles_test.go deleted file mode 100644 index c8574bec6..000000000 --- a/x/pricefeed/keeper/grpc_query_oracles_test.go +++ /dev/null @@ -1,47 +0,0 @@ -package keeper_test - -import ( - "testing" - - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/stretchr/testify/require" - - "github.com/NibiruChain/nibiru/x/pricefeed/types" - testkeeper "github.com/NibiruChain/nibiru/x/testutil/keeper" -) - -func TestOraclesQuery(t *testing.T) { - keeper, ctx := testkeeper.PricefeedKeeper(t) - wctx := sdk.WrapSDKContext(ctx) - params := types.Params{ - Pairs: []types.Pair{ - {Token1: "btc", Token0: "usd", Oracles: nil, Active: true}, - {Token1: "xrp", Token0: "usd", Oracles: nil, Active: true}, - {Token1: "ada", Token0: "usd", Oracles: []sdk.AccAddress{ - []byte("some oracle address"), []byte("some other oracle address"), - }, Active: true}, - {Token1: "eth", Token0: "usd", Oracles: []sdk.AccAddress{[]byte("random oracle address")}, Active: false}, - }, - } - keeper.SetParams(ctx, params) - - // Use the ADA pair to query for oracles - adaPair := params.Pairs[2] - response, err := keeper.Oracles(wctx, &types.QueryOraclesRequest{PairId: adaPair.PairID()}) - require.NoError(t, err) - require.Equal(t, &types.QueryOraclesResponse{Oracles: oraclesToAddress(adaPair.Oracles)}, response) - - // Use the ETH pair to query for oracles - ethPair := params.Pairs[3] - response, err = keeper.Oracles(wctx, &types.QueryOraclesRequest{PairId: ethPair.PairID()}) - require.NoError(t, err) - require.Equal(t, &types.QueryOraclesResponse{Oracles: oraclesToAddress(ethPair.Oracles)}, response) -} - -func oraclesToAddress(accAddress []sdk.AccAddress) []string { - r := []string{} - for _, a := range accAddress { - r = append(r, a.String()) - } - return r -} diff --git a/x/pricefeed/keeper/grpc_query_params.go b/x/pricefeed/keeper/grpc_query_params.go deleted file mode 100644 index 2b3a39260..000000000 --- a/x/pricefeed/keeper/grpc_query_params.go +++ /dev/null @@ -1,20 +0,0 @@ -package keeper - -import ( - "context" - - sdk "github.com/cosmos/cosmos-sdk/types" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" - - "github.com/NibiruChain/nibiru/x/pricefeed/types" -) - -func (k Keeper) Params(c context.Context, req *types.QueryParamsRequest) (*types.QueryParamsResponse, error) { - if req == nil { - return nil, status.Error(codes.InvalidArgument, "invalid request") - } - ctx := sdk.UnwrapSDKContext(c) - - return &types.QueryParamsResponse{Params: k.GetParams(ctx)}, nil -} diff --git a/x/pricefeed/keeper/grpc_query_params_test.go b/x/pricefeed/keeper/grpc_query_params_test.go deleted file mode 100644 index 224a12a84..000000000 --- a/x/pricefeed/keeper/grpc_query_params_test.go +++ /dev/null @@ -1,27 +0,0 @@ -package keeper_test - -import ( - "testing" - - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/stretchr/testify/require" - - "github.com/NibiruChain/nibiru/x/pricefeed/types" - testutilkeeper "github.com/NibiruChain/nibiru/x/testutil/keeper" -) - -func TestParamsQuery(t *testing.T) { - keeper, ctx := testutilkeeper.PricefeedKeeper(t) - wctx := sdk.WrapSDKContext(ctx) - params := types.Params{ - Pairs: []types.Pair{ - {Token1: "btc", Token0: "usd", Oracles: nil, Active: true}, - {Token1: "xrp", Token0: "usd", Oracles: nil, Active: true}, - }, - } - keeper.SetParams(ctx, params) - - response, err := keeper.Params(wctx, &types.QueryParamsRequest{}) - require.NoError(t, err) - require.Equal(t, &types.QueryParamsResponse{Params: params}, response) -} diff --git a/x/pricefeed/keeper/grpc_query_price.go b/x/pricefeed/keeper/grpc_query_price.go deleted file mode 100644 index df7ac61a5..000000000 --- a/x/pricefeed/keeper/grpc_query_price.go +++ /dev/null @@ -1,35 +0,0 @@ -package keeper - -import ( - "context" - - sdk "github.com/cosmos/cosmos-sdk/types" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" - - "github.com/NibiruChain/nibiru/x/common" - "github.com/NibiruChain/nibiru/x/pricefeed/types" -) - -func (k Keeper) Price(goCtx context.Context, req *types.QueryPriceRequest) (*types.QueryPriceResponse, error) { - if req == nil { - return nil, status.Error(codes.InvalidArgument, "invalid request") - } - - ctx := sdk.UnwrapSDKContext(goCtx) - - _, found := k.GetPair(ctx, req.PairId) - if !found { - return nil, status.Error(codes.NotFound, "invalid market ID") - } - tokens := common.DenomsFromPoolName(req.PairId) - token0, token1 := tokens[0], tokens[1] - currentPrice, sdkErr := k.GetCurrentPrice(ctx, token0, token1) - if sdkErr != nil { - return nil, sdkErr - } - - return &types.QueryPriceResponse{ - Price: types.CurrentPriceResponse{PairID: req.PairId, Price: currentPrice.Price}, - }, nil -} diff --git a/x/pricefeed/keeper/grpc_query_prices.go b/x/pricefeed/keeper/grpc_query_prices.go deleted file mode 100644 index 3f37b8924..000000000 --- a/x/pricefeed/keeper/grpc_query_prices.go +++ /dev/null @@ -1,30 +0,0 @@ -package keeper - -import ( - "context" - - sdk "github.com/cosmos/cosmos-sdk/types" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" - - "github.com/NibiruChain/nibiru/x/pricefeed/types" -) - -func (k Keeper) Prices(goCtx context.Context, req *types.QueryPricesRequest) (*types.QueryPricesResponse, error) { - if req == nil { - return nil, status.Error(codes.InvalidArgument, "invalid request") - } - - ctx := sdk.UnwrapSDKContext(goCtx) - - var currentPrices types.CurrentPriceResponses - for _, cp := range k.GetCurrentPrices(ctx) { - if cp.PairID != "" { - currentPrices = append(currentPrices, types.CurrentPriceResponse(cp)) - } - } - - return &types.QueryPricesResponse{ - Prices: currentPrices, - }, nil -} diff --git a/x/pricefeed/keeper/grpc_query_raw_prices.go b/x/pricefeed/keeper/grpc_query_raw_prices.go deleted file mode 100644 index 84788d9d1..000000000 --- a/x/pricefeed/keeper/grpc_query_raw_prices.go +++ /dev/null @@ -1,38 +0,0 @@ -package keeper - -import ( - "context" - - sdk "github.com/cosmos/cosmos-sdk/types" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" - - "github.com/NibiruChain/nibiru/x/pricefeed/types" -) - -func (k Keeper) RawPrices(goCtx context.Context, req *types.QueryRawPricesRequest) (*types.QueryRawPricesResponse, error) { - if req == nil { - return nil, status.Error(codes.InvalidArgument, "invalid request") - } - - ctx := sdk.UnwrapSDKContext(goCtx) - - _, found := k.GetPair(ctx, req.PairId) - if !found { - return nil, status.Error(codes.NotFound, "invalid market ID") - } - - var prices types.PostedPriceResponses - for _, rp := range k.GetRawPrices(ctx, req.PairId) { - prices = append(prices, types.PostedPriceResponse{ - PairID: rp.PairID, - OracleAddress: rp.OracleAddress.String(), - Price: rp.Price, - Expiry: rp.Expiry, - }) - } - - return &types.QueryRawPricesResponse{ - RawPrices: prices, - }, nil -} diff --git a/x/pricefeed/keeper/grpc_query_test.go b/x/pricefeed/keeper/grpc_query_test.go new file mode 100644 index 000000000..6d2bced71 --- /dev/null +++ b/x/pricefeed/keeper/grpc_query_test.go @@ -0,0 +1,117 @@ +package keeper_test + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/NibiruChain/nibiru/x/common" + "github.com/NibiruChain/nibiru/x/pricefeed/types" + testutilkeeper "github.com/NibiruChain/nibiru/x/testutil/keeper" + "github.com/NibiruChain/nibiru/x/testutil/sample" +) + +func TestParamsQuery(t *testing.T) { + keeper, ctx := testutilkeeper.PricefeedKeeper(t) + wctx := sdk.WrapSDKContext(ctx) + params := types.Params{Pairs: common.NewAssetPairs("btc:usd", "xrp:usd")} + keeper.SetParams(ctx, params) + + response, err := keeper.QueryParams(wctx, &types.QueryParamsRequest{}) + require.NoError(t, err) + require.Equal(t, &types.QueryParamsResponse{Params: params}, response) +} + +func TestOraclesQuery(t *testing.T) { + keeper, ctx := testutilkeeper.PricefeedKeeper(t) + wctx := sdk.WrapSDKContext(ctx) + pairs := common.NewAssetPairs("usd:btc", "usd:xrp", "usd:ada", "usd:eth") + params := types.Params{Pairs: pairs} + keeper.SetParams(ctx, params) + + _, addrs := sample.PrivKeyAddressPairs(3) + oracleA, oracleB, oracleC := addrs[0], addrs[1], addrs[2] + + t.Log("whitelist oracles A, B on pair 2") + keeper.WhitelistOraclesForPairs( + ctx, + /*oracles=*/ []sdk.AccAddress{oracleA, oracleB}, + /*pairs=*/ []common.AssetPair{pairs[2]}) + + t.Log("whitelist oracle C on pair 3") + keeper.WhitelistOraclesForPairs( + ctx, + /*oracles=*/ []sdk.AccAddress{oracleC}, + /*pairs=*/ []common.AssetPair{pairs[3]}) + + t.Log("Query for pair 2 oracles | ADA") + response, err := keeper.QueryOracles(wctx, &types.QueryOraclesRequest{ + PairId: pairs[2].String()}) + require.NoError(t, err) + require.Equal(t, &types.QueryOraclesResponse{ + Oracles: []string{oracleA.String(), oracleB.String()}}, response) + + t.Log("Query for pair 3 oracles | ETH") + response, err = keeper.QueryOracles(wctx, &types.QueryOraclesRequest{ + PairId: pairs[3].String()}) + require.NoError(t, err) + require.Equal(t, &types.QueryOraclesResponse{ + Oracles: []string{oracleC.String()}}, response) +} + +func TestMarketsQuery(t *testing.T) { + keeper, ctx := testutilkeeper.PricefeedKeeper(t) + wctx := sdk.WrapSDKContext(ctx) + pairs := common.NewAssetPairs("btc:usd", "xrp:usd", "ada:usd", "eth:usd") + params := types.Params{Pairs: pairs} + keeper.SetParams(ctx, params) + + t.Log("Give pairs 2 and 3 distinct oracles") + oracle2, oracle3 := sample.AccAddress(), sample.AccAddress() + keeper.OraclesStore().AddOracles(ctx, pairs[2], []sdk.AccAddress{oracle2}) + keeper.OraclesStore().AddOracles(ctx, pairs[3], []sdk.AccAddress{oracle3}) + + t.Log("Set all pairs but 3 active") + keeper.ActivePairsStore().SetMany(ctx, pairs[:3], true) + keeper.ActivePairsStore().SetMany(ctx, common.AssetPairs{pairs[3]}, false) + + response, err := keeper.QueryPairs(wctx, &types.QueryPairsRequest{}) + require.NoError(t, err) + expectedResponse := &types.QueryPairsResponse{ + Pairs: []types.PairResponse{ + { + PairID: pairs[0].String(), + Token0: pairs[0].Token0, + Token1: pairs[0].Token1, + Oracles: []string(nil), + Active: true, + }, + { + PairID: pairs[1].String(), + Token0: pairs[1].Token0, + Token1: pairs[1].Token1, + Oracles: []string(nil), + Active: true, + }, + { + PairID: pairs[2].String(), + Token0: pairs[2].Token0, + Token1: pairs[2].Token1, + Oracles: []string{oracle2.String()}, + Active: true, + }, + { + PairID: pairs[3].String(), + Token0: pairs[3].Token0, + Token1: pairs[3].Token1, + Oracles: []string{oracle3.String()}, + Active: false, + }, + }, + } + for idx, pairResponse := range expectedResponse.Pairs { + assert.EqualValues(t, pairResponse, response.Pairs[idx]) + } +} diff --git a/x/pricefeed/keeper/keeper.go b/x/pricefeed/keeper/keeper.go index 0d47aa645..012e74edc 100644 --- a/x/pricefeed/keeper/keeper.go +++ b/x/pricefeed/keeper/keeper.go @@ -55,34 +55,41 @@ func (k Keeper) Logger(ctx sdk.Context) log.Logger { func (k Keeper) SetPrice( ctx sdk.Context, oracle sdk.AccAddress, - token0 string, - token1 string, + pairStr string, price sdk.Dec, expiry time.Time, -) (types.PostedPrice, error) { +) (postedPrice types.PostedPrice, err error) { // If the posted price expires before the current block, it is invalid. if expiry.Before(ctx.BlockTime()) { - return types.PostedPrice{}, types.ErrExpired + return postedPrice, types.ErrExpired } - // TODO: test this behavior when setting the inverse pair - pairName := common.RawPoolNameFromDenoms([]string{token0, token1}) - pairID := common.PoolNameFromDenoms([]string{token0, token1}) - if (pairName != pairID) && (!price.Equal(sdk.ZeroDec())) { - price = sdk.OneDec().Quo(price) + if !price.IsPositive() { + return postedPrice, fmt.Errorf("price must be positive, not: %s", price) } - _, err := k.GetOracle(ctx, pairID, oracle) + pair, err := common.NewAssetPair(pairStr) if err != nil { - return types.PostedPrice{}, err + return postedPrice, err } - newRawPrice := types.NewPostedPrice(pairID, oracle, price, expiry) + // Set inverse price if the oracle gives the wrong string + if k.IsActivePair(ctx, pair.Inverse().String()) { + pair = pair.Inverse() + price = sdk.OneDec().Quo(price) + } + + if !k.IsWhitelistedOracle(ctx, pair.String(), oracle) { + return types.PostedPrice{}, fmt.Errorf( + "oracle %s cannot post on pair %v", oracle, pair.String()) + } + + newPostedPrice := types.NewPostedPrice(pair, oracle, price, expiry) // Emit an event containing the oracle's new price err = ctx.EventManager().EmitTypedEvent(&types.EventOracleUpdatePrice{ - PairId: pairID, + PairId: pair.String(), Oracle: oracle.String(), PairPrice: price, Expiry: expiry, @@ -93,19 +100,16 @@ func (k Keeper) SetPrice( // Sets the raw price for a single oracle instead of an array of all oracle's raw prices store := ctx.KVStore(k.storeKey) - store.Set(types.RawPriceKey(pairID, oracle), k.cdc.MustMarshal(&newRawPrice)) - return newRawPrice, nil + store.Set(types.RawPriceKey(pair.String(), oracle), k.cdc.MustMarshal(&newPostedPrice)) + return newPostedPrice, nil } // SetCurrentPrices updates the price of an asset to the median of all valid oracle inputs func (k Keeper) SetCurrentPrices(ctx sdk.Context, token0 string, token1 string) error { assetPair := common.AssetPair{Token0: token0, Token1: token1} - pairID := assetPair.Name() - tokens := common.DenomsFromPoolName(pairID) - token0, token1 = tokens[0], tokens[1] + pairID := assetPair.String() - _, ok := k.GetPair(ctx, pairID) - if !ok { + if !k.IsActivePair(ctx, pairID) { return sdkerrors.Wrap(types.ErrInvalidPair, pairID) } // store current price @@ -171,10 +175,10 @@ func (k Keeper) setCurrentPrice(ctx sdk.Context, pairID string, currentPrice typ We use the blocktime to update the twap price. Calculation is done as follow: - $$P_{TWAP} = \frac {\sum {P_j \times Bh_j }}{\sum{Bh_j}} $$ + $$P_{TWAP} = \frac { \sum P_j \times t_B }{ \sum{t_B} } $$ With P_j: current posted price for the pair of tokens - Bh_j: current block timestamp + t_B: current block timestamp */ @@ -245,24 +249,27 @@ func (k Keeper) calculateMeanPrice(priceA, priceB types.CurrentPrice) sdk.Dec { // GetCurrentPrice fetches the current median price of all oracles for a specific market func (k Keeper) GetCurrentPrice(ctx sdk.Context, token0 string, token1 string, ) (currPrice types.CurrentPrice, err error) { - assetPair := common.AssetPair{Token0: token0, Token1: token1} - pairID := assetPair.Name() + pair := common.AssetPair{Token0: token0, Token1: token1} + givenIsActive := k.IsActivePair(ctx, pair.String()) + inverseIsActive := k.IsActivePair(ctx, pair.Inverse().String()) + if !givenIsActive && inverseIsActive { + pair = pair.Inverse() + } + // Retrieve current price from the KV store store := ctx.KVStore(k.storeKey) - bz := store.Get(types.CurrentPriceKey(pairID)) - + bz := store.Get(types.CurrentPriceKey(pair.String())) if bz == nil { return types.CurrentPrice{}, types.ErrNoValidPrice } - var price types.CurrentPrice k.cdc.MustUnmarshal(bz, &price) if price.Price.Equal(sdk.ZeroDec()) { return types.CurrentPrice{}, types.ErrNoValidPrice } - if !assetPair.IsProperOrder() { - // Return the inverse price if the tokens are not in "proper" order. + if inverseIsActive { + // Return the inverse price if the tokens are not in params order. inversePrice := sdk.OneDec().Quo(price.Price) return types.NewCurrentPrice( /* token0 */ token1, @@ -275,17 +282,21 @@ func (k Keeper) GetCurrentPrice(ctx sdk.Context, token0 string, token1 string, // GetCurrentTWAPPrice fetches the current median price of all oracles for a specific market func (k Keeper) GetCurrentTWAPPrice(ctx sdk.Context, token0 string, token1 string) (currPrice types.CurrentTWAP, err error) { + pair := common.AssetPair{Token0: token0, Token1: token1} + givenIsActive := k.IsActivePair(ctx, pair.String()) + inverseIsActive := k.IsActivePair(ctx, pair.Inverse().String()) + if !givenIsActive && inverseIsActive { + pair = pair.Inverse() + } + // Ensure we still have valid prices _, err = k.GetCurrentPrice(ctx, token0, token1) if err != nil { return types.CurrentTWAP{}, types.ErrNoValidPrice } - assetPair := common.AssetPair{Token0: token0, Token1: token1} - pairID := assetPair.Name() - store := ctx.KVStore(k.storeKey) - bz := store.Get(types.CurrentTWAPPriceKey("twap-" + pairID)) + bz := store.Get(types.CurrentTWAPPriceKey("twap-" + pair.String())) if bz == nil { return types.CurrentTWAP{}, types.ErrNoValidTWAP @@ -297,7 +308,7 @@ func (k Keeper) GetCurrentTWAPPrice(ctx sdk.Context, token0 string, token1 strin return types.CurrentTWAP{}, types.ErrNoValidPrice } - if !assetPair.IsProperOrder() { + if inverseIsActive { // Return the inverse price if the tokens are not in "proper" order. inversePrice := sdk.OneDec().Quo(price.Price) return types.NewCurrentTWAP( @@ -335,9 +346,16 @@ func (k Keeper) GetCurrentPrices(ctx sdk.Context) types.CurrentPrices { } // GetRawPrices fetches the set of all prices posted by oracles for an asset -func (k Keeper) GetRawPrices(ctx sdk.Context, marketId string) types.PostedPrices { +func (k Keeper) GetRawPrices(ctx sdk.Context, pairStr string) types.PostedPrices { + inversePair := common.MustNewAssetPair(pairStr).Inverse() + if k.IsActivePair(ctx, inversePair.String()) { + panic(fmt.Errorf( + `cannot fetch posted prices using inverse pair, %v ; + Use pair, %v, instead`, inversePair.String(), pairStr)) + } + var pps types.PostedPrices - k.IterateRawPricesByPair(ctx, marketId, func(pp types.PostedPrice) (stop bool) { + k.IterateRawPricesByPair(ctx, pairStr, func(pp types.PostedPrice) (stop bool) { pps = append(pps, pp) return false }) diff --git a/x/pricefeed/keeper/keeper_test.go b/x/pricefeed/keeper/keeper_test.go index 37e89298e..0657eace2 100644 --- a/x/pricefeed/keeper/keeper_test.go +++ b/x/pricefeed/keeper/keeper_test.go @@ -5,107 +5,88 @@ import ( "time" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/pricefeed/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestKeeper_SetGetPair(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) - token0, token1 := "usd", "tst" - tstusdPair := types.Pair{ - Token1: token1, Token0: token0, Oracles: []sdk.AccAddress{}, Active: true} - token0, token1 = "abc", "xyz" - abcxyzPair := types.Pair{ - Token1: token1, Token0: token0, Oracles: []sdk.AccAddress{}, Active: true} - - mp := types.Params{ - Pairs: types.Pairs{tstusdPair}, + pairs := common.AssetPairs{ + common.MustNewAssetPair("tst:usd"), + common.MustNewAssetPair("xyz:abc"), } - keeper := app.PricefeedKeeper - keeper.SetParams(ctx, mp) - markets := keeper.GetPairs(ctx) - require.Equal(t, len(markets), 1) - require.Equal(t, markets[0].PairID(), "tst:usd") + keeper := app.PricefeedKeeper + keeper.SetParams(ctx, types.Params{Pairs: common.AssetPairs{pairs[0]}}) - _, found := keeper.GetPair(ctx, "tst:usd") - require.True(t, found, "market should be found") + paramsPairs := keeper.GetPairs(ctx) + require.Len(t, paramsPairs, 1) + require.Equal(t, paramsPairs[0].String(), "tst:usd") - _, found = keeper.GetPair(ctx, "invalid:market") - require.False(t, found, "invalid:market should not be found") + require.True(t, keeper.IsActivePair(ctx, pairs[0].String())) + require.True(t, !keeper.IsActivePair(ctx, pairs[1].String())) - mp = types.Params{ - Pairs: []types.Pair{ - tstusdPair, - abcxyzPair, - }, + params := types.Params{Pairs: pairs} + keeper.SetParams(ctx, params) + paramsPairs = keeper.GetPairs(ctx) + require.Len(t, paramsPairs, 2) + for _, pair := range paramsPairs { + require.True(t, keeper.IsActivePair(ctx, pair.String())) } - - keeper.SetParams(ctx, mp) - markets = keeper.GetPairs(ctx) - require.Equal(t, len(markets), 2) - require.Equal(t, markets[0].PairID(), "tst:usd") - _, found = keeper.GetPair(ctx, "abc:xyz") - require.True(t, found, "market should be found") - - _, found = keeper.GetPair(ctx, "nan") - require.False(t, found) + require.False(t, keeper.IsActivePair(ctx, "nan:nan")) } func TestKeeper_GetSetPrice(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) keeper := app.PricefeedKeeper _, addrs := sample.PrivKeyAddressPairs(2) - mp := types.Params{ - Pairs: []types.Pair{ - {Token1: "tst", Token0: "usd", Oracles: addrs, Active: true}, - }, - } - keeper.SetParams(ctx, mp) - - token0, token1 := "tst", "usd" - pairID := "tst:usd" - prices := []struct { - oracle sdk.AccAddress - token0 string - token1 string - price sdk.Dec - total int + pair := common.MustNewAssetPair("tst:usd") + params := types.Params{Pairs: common.AssetPairs{pair}} + keeper.SetParams(ctx, params) + keeper.OraclesStore().AddOracles(ctx, pair, addrs) + + priceInfos := []struct { + oracle sdk.AccAddress + pairStr string + price sdk.Dec + total int }{ - {addrs[0], token0, token1, sdk.MustNewDecFromStr("0.33"), 1}, - {addrs[1], token0, token1, sdk.MustNewDecFromStr("0.35"), 2}, - {addrs[0], token0, token1, sdk.MustNewDecFromStr("0.37"), 2}, + {addrs[0], pair.String(), sdk.MustNewDecFromStr("0.33"), 1}, + {addrs[1], pair.String(), sdk.MustNewDecFromStr("0.35"), 2}, + {addrs[0], pair.String(), sdk.MustNewDecFromStr("0.37"), 2}, } - for _, p := range prices { + for _, priceInfo := range priceInfos { // Set price by oracle 1 - pp, err := keeper.SetPrice( ctx, - p.oracle, - p.token0, - p.token1, - p.price, + priceInfo.oracle, + priceInfo.pairStr, + priceInfo.price, time.Now().UTC().Add(1*time.Hour), ) require.NoError(t, err) // Get raw prices - rawPrices := keeper.GetRawPrices(ctx, pairID) + rawPrices := keeper.GetRawPrices(ctx, pair.String()) - require.Equal(t, p.total, len(rawPrices)) + require.Equal(t, priceInfo.total, len(rawPrices)) require.Contains(t, rawPrices, pp) // Find the oracle and require price to be same - for _, rp := range rawPrices { - if p.oracle.Equals(rp.OracleAddress) { - require.Equal(t, p.price, rp.Price) + for _, postedPrice := range rawPrices { + oracleThatPosted, err := sdk.AccAddressFromBech32(postedPrice.Oracle) + assert.NoError(t, err) + if priceInfo.oracle.Equals(oracleThatPosted) { + require.Equal(t, priceInfo.price, postedPrice.Price) } } } @@ -116,29 +97,29 @@ Test case where two oracles try to set prices for a market and only one of the oracles is valid (i.e. registered with keeper.SetParams). */ func TestKeeper_SetPriceWrongOracle(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) keeper := app.PricefeedKeeper - token0, token1 := "tst", "usd" + pair := common.MustNewAssetPair("tst:usd") + price := sdk.MustNewDecFromStr("0.1") // Register addrs[1] as the oracle. _, addrs := sample.PrivKeyAddressPairs(2) - mp := types.Params{ - Pairs: []types.Pair{ - {Token1: token1, Token0: token0, - Oracles: addrs[:1], Active: true}, - }} - keeper.SetParams(ctx, mp) - - // Set price with valid oracle given (addrs[1]) + + params := types.Params{Pairs: common.AssetPairs{pair}} + keeper.SetParams(ctx, params) + + // Set price with valid oracle given (addrs[0]) + keeper.WhitelistOracles(ctx, []sdk.AccAddress{addrs[0]}) + expiry := ctx.BlockTime().UTC().Add(1 * time.Hour) _, err := keeper.SetPrice( - ctx, addrs[0], token0, token1, price, time.Now().UTC().Add(1*time.Hour), + ctx, addrs[0], pair.String(), price, expiry, ) require.NoError(t, err) // Set price with invalid oracle given (addrs[1]) _, err = keeper.SetPrice( - ctx, addrs[1], token0, token1, price, time.Now().UTC().Add(1*time.Hour), + ctx, addrs[1], pair.String(), price, expiry, ) require.Error(t, err) } @@ -148,32 +129,30 @@ Test case where several oracles try to set prices for a market and "k" (int) of the oracles are valid (i.e. registered with keeper.SetParams). */ func TestKeeper_SetPriceWrongOracles(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) keeper := app.PricefeedKeeper - token0, token1 := "tst", "usd" + pair := common.MustNewAssetPair("tst:usd") price := sdk.MustNewDecFromStr("0.1") _, addrs := sample.PrivKeyAddressPairs(10) - mp := types.Params{ - Pairs: []types.Pair{ - {Token1: "tst", Token0: "usd", - Oracles: addrs[:5], Active: true}, - }, + params := types.Params{ + Pairs: common.AssetPairs{pair}, } - keeper.SetParams(ctx, mp) + keeper.SetParams(ctx, params) + keeper.WhitelistOraclesForPairs(ctx, addrs[:5], common.AssetPairs{pair}) for i, addr := range addrs { if i < 5 { // Valid oracle addresses. This shouldn't raise an error. _, err := keeper.SetPrice( - ctx, addr, token0, token1, price, time.Now().UTC().Add(1*time.Hour), + ctx, addr, pair.String(), price, time.Now().UTC().Add(1*time.Hour), ) require.NoError(t, err) } else { // Invalid oracle addresses. This should raise errors. _, err := keeper.SetPrice( - ctx, addr, token0, token1, price, time.Now().UTC().Add(1*time.Hour), + ctx, addr, pair.String(), price, time.Now().UTC().Add(1*time.Hour), ) require.Error(t, err) } @@ -183,46 +162,45 @@ func TestKeeper_SetPriceWrongOracles(t *testing.T) { // TestKeeper_GetSetCurrentPrice Test Setting the median price of an Asset func TestKeeper_GetSetCurrentPrice(t *testing.T) { _, addrs := sample.PrivKeyAddressPairs(5) - app, ctx := testutilapp.NewNibiruApp(true) + app, ctx := testapp.NewNibiruAppAndContext(true) keeper := app.PricefeedKeeper token0, token1 := "tst", "usd" - mp := types.Params{ - Pairs: []types.Pair{ - {Token0: token0, Token1: token1, - Oracles: addrs, Active: true}, - }, + pair := common.AssetPair{Token0: token0, Token1: token1} + params := types.Params{ + Pairs: common.AssetPairs{pair}, } - keeper.SetParams(ctx, mp) + keeper.OraclesStore().AddOracles(ctx, pair, addrs) + keeper.SetParams(ctx, params) _, err := keeper.SetPrice( - ctx, addrs[0], token0, token1, + ctx, addrs[0], pair.String(), sdk.MustNewDecFromStr("0.33"), time.Now().Add(time.Hour*1)) require.NoError(t, err) _, err = keeper.SetPrice( - ctx, addrs[1], token0, token1, + ctx, addrs[1], pair.String(), sdk.MustNewDecFromStr("0.35"), time.Now().Add(time.Hour*1)) require.NoError(t, err) _, err = keeper.SetPrice( - ctx, addrs[2], token0, token1, + ctx, addrs[2], pair.String(), sdk.MustNewDecFromStr("0.34"), time.Now().Add(time.Hour*1)) require.NoError(t, err) - // Add an expired one which should fail + t.Log("Add an expired one which should fail") _, err = keeper.SetPrice( - ctx, addrs[3], token0, token1, + ctx, addrs[3], pair.String(), sdk.MustNewDecFromStr("0.9"), ctx.BlockTime().Add(-time.Hour*1)) require.Error(t, err) - // Add a non-expired price, but will not be counted when BlockTime is changed + t.Log("Add a non-expired price, but will not be counted when BlockTime is changed") _, err = keeper.SetPrice( - ctx, addrs[3], token0, token1, + ctx, addrs[3], pair.String(), sdk.MustNewDecFromStr("0.9"), time.Now().Add(time.Minute*30)) require.NoError(t, err) @@ -231,24 +209,24 @@ func TestKeeper_GetSetCurrentPrice(t *testing.T) { ctx = ctx.WithBlockTime(time.Now().Add(time.Minute * 45)) // Set current price - err = keeper.SetCurrentPrices(ctx, "tst", "usd") + err = keeper.SetCurrentPrices(ctx, token0, token1) require.NoError(t, err) // Get current price - price, err := keeper.GetCurrentPrice(ctx, "tst", "usd") - require.Nil(t, err) + price, err := keeper.GetCurrentPrice(ctx, token0, token1) + require.NoError(t, err) expCurPrice := sdk.MustNewDecFromStr("0.34") require.Truef( t, price.Price.Equal(expCurPrice), - "expected current price to equal %v, actual %v", + "expected current price to equal %s, actual %s", expCurPrice, price.Price, ) // Even number of oracles _, err = keeper.SetPrice( - ctx, addrs[4], token0, token1, + ctx, addrs[4], pair.String(), sdk.MustNewDecFromStr("0.36"), time.Now().Add(time.Hour*1)) require.NoError(t, err) @@ -272,32 +250,32 @@ func TestKeeper_GetSetCurrentPrice(t *testing.T) { } func TestKeeper_ExpiredSetCurrentPrices(t *testing.T) { - _, addrs := sample.PrivKeyAddressPairs(5) - app, ctx := testutilapp.NewNibiruApp(true) + _, oracles := sample.PrivKeyAddressPairs(5) + app, ctx := testapp.NewNibiruAppAndContext(true) keeper := app.PricefeedKeeper token0, token1 := "usd", "tst" - mp := types.Params{ - Pairs: []types.Pair{ - {Token1: token1, Token0: token0, Oracles: addrs, Active: true}, - }, + pair := common.AssetPair{Token0: token0, Token1: token1} + params := types.Params{ + Pairs: common.AssetPairs{pair}, } - keeper.SetParams(ctx, mp) + keeper.SetParams(ctx, params) + keeper.OraclesStore().AddOracles(ctx, pair, oracles) _, err := keeper.SetPrice( - ctx, addrs[0], token0, token1, + ctx, oracles[0], pair.String(), sdk.MustNewDecFromStr("0.33"), time.Now().Add(time.Hour*1)) require.NoError(t, err) _, err = keeper.SetPrice( - ctx, addrs[1], token0, token1, + ctx, oracles[1], pair.String(), sdk.MustNewDecFromStr("0.35"), time.Now().Add(time.Hour*1)) require.NoError(t, err) _, err = keeper.SetPrice( - ctx, addrs[2], token0, token1, + ctx, oracles[2], pair.String(), sdk.MustNewDecFromStr("0.34"), time.Now().Add(time.Hour*1)) require.NoError(t, err) @@ -306,7 +284,7 @@ func TestKeeper_ExpiredSetCurrentPrices(t *testing.T) { ctx = ctx.WithBlockTime(time.Now().UTC().Add(time.Hour * 2)) err = keeper.SetCurrentPrices(ctx, token0, token1) - require.ErrorIs(t, types.ErrNoValidPrice, err, "there should be no valid prices to be set") + require.ErrorContains(t, err, "input prices are expired") _, err = keeper.GetCurrentPrice(ctx, token0, token1) require.ErrorIs(t, types.ErrNoValidPrice, err, "current prices should be invalid") diff --git a/x/pricefeed/keeper/msg_server.go b/x/pricefeed/keeper/msg_server.go index e4091b589..bb35dddc2 100644 --- a/x/pricefeed/keeper/msg_server.go +++ b/x/pricefeed/keeper/msg_server.go @@ -1,6 +1,13 @@ package keeper import ( + "context" + + sdk "github.com/cosmos/cosmos-sdk/types" + + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + + "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/pricefeed/types" ) @@ -15,3 +22,51 @@ func NewMsgServerImpl(keeper Keeper) types.MsgServer { } var _ types.MsgServer = msgServer{} + +// --------------------------------------------------------------- +// PostPrice +// --------------------------------------------------------------- + +func (k msgServer) PostPrice(goCtx context.Context, msg *types.MsgPostPrice, +) (*types.MsgPostPriceResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + from, err := sdk.AccAddressFromBech32(msg.From) + if err != nil { + return nil, err + } + + pair := common.AssetPair{Token0: msg.Token0, Token1: msg.Token1} + + isWhitelisted := k.IsWhitelistedOracle(ctx, pair.String(), from) + isWhitelistedForInverse := k.IsWhitelistedOracle( + ctx, pair.Inverse().String(), from) + if !(isWhitelisted || isWhitelistedForInverse) { + return nil, sdkerrors.Wrapf(types.ErrInvalidOracle, + `oracle is not whitelisted for pair %v + oracle: %s`, pair.String(), from) + } + + var postedPrice sdk.Dec + if isWhitelistedForInverse { + postedPrice = sdk.OneDec().Quo(msg.Price) + pair = pair.Inverse() + } else { + postedPrice = msg.Price + } + + _, err = k.SetPrice(ctx, from, pair.String(), postedPrice, msg.Expiry) + if err != nil { + return nil, err + } + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + sdk.EventTypeMessage, + sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName), + sdk.NewAttribute(sdk.AttributeKeySender, msg.From), + ), + ) + + return &types.MsgPostPriceResponse{}, nil +} diff --git a/x/pricefeed/keeper/msg_server_post_price.go b/x/pricefeed/keeper/msg_server_post_price.go deleted file mode 100644 index 983e6ea0a..000000000 --- a/x/pricefeed/keeper/msg_server_post_price.go +++ /dev/null @@ -1,41 +0,0 @@ -package keeper - -import ( - "context" - - sdk "github.com/cosmos/cosmos-sdk/types" - - "github.com/NibiruChain/nibiru/x/common" - "github.com/NibiruChain/nibiru/x/pricefeed/types" -) - -func (k msgServer) PostPrice(goCtx context.Context, msg *types.MsgPostPrice) (*types.MsgPostPriceResponse, error) { - ctx := sdk.UnwrapSDKContext(goCtx) - - from, err := sdk.AccAddressFromBech32(msg.From) - if err != nil { - return nil, err - } - - pairID := common.PoolNameFromDenoms([]string{msg.Token0, msg.Token1}) - _, err = k.GetOracle(ctx, pairID, from) - if err != nil { - return nil, err - } - - _, err = k.SetPrice(ctx, from, msg.Token0, msg.Token1, msg.Price, msg.Expiry) - - if err != nil { - return nil, err - } - - ctx.EventManager().EmitEvent( - sdk.NewEvent( - sdk.EventTypeMessage, - sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName), - sdk.NewAttribute(sdk.AttributeKeySender, msg.From), - ), - ) - - return &types.MsgPostPriceResponse{}, nil -} diff --git a/x/pricefeed/keeper/msg_server_test.go b/x/pricefeed/keeper/msg_server_test.go index f2c351466..f0ca7382f 100644 --- a/x/pricefeed/keeper/msg_server_test.go +++ b/x/pricefeed/keeper/msg_server_test.go @@ -7,6 +7,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/stretchr/testify/require" + "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/pricefeed/keeper" "github.com/NibiruChain/nibiru/x/pricefeed/types" testutilkeeper "github.com/NibiruChain/nibiru/x/testutil/keeper" @@ -21,12 +22,12 @@ func TestPostPrice(t *testing.T) { authorizedOracles := addrs[:2] unauthorizedAddrs := addrs[2:] - mp := types.Params{ - Pairs: []types.Pair{ - {Token1: "tst", Token0: "usd", Oracles: authorizedOracles, Active: true}, - }, + pair := common.MustNewAssetPair("usd:tst") + params := types.Params{ + Pairs: common.AssetPairs{pair}, } - k.SetParams(ctx, mp) + k.SetParams(ctx, params) + k.WhitelistOraclesForPairs(ctx, authorizedOracles, common.AssetPairs{pair}) tests := []struct { giveMsg string @@ -42,7 +43,7 @@ func TestPostPrice(t *testing.T) { {"expired", authorizedOracles[0], "tst", "usd", ctx.BlockTime().UTC().Add(-time.Hour * 1), false, types.ErrExpired}, {"invalid", authorizedOracles[0], "invalid", "invalid", - ctx.BlockTime().UTC().Add(time.Hour * 1), false, types.ErrInvalidPair}, + ctx.BlockTime().UTC().Add(time.Hour * 1), false, types.ErrInvalidOracle}, {"unauthorized", unauthorizedAddrs[0], "tst", "usd", ctx.BlockTime().UTC().Add(time.Hour * 1), false, types.ErrInvalidOracle}, } diff --git a/x/pricefeed/keeper/params.go b/x/pricefeed/keeper/params.go index d94f579a4..73f0df0bb 100644 --- a/x/pricefeed/keeper/params.go +++ b/x/pricefeed/keeper/params.go @@ -2,8 +2,8 @@ package keeper import ( sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/pricefeed/types" ) @@ -17,86 +17,98 @@ func (k Keeper) GetParams(ctx sdk.Context) types.Params { // SetParams set the params func (k Keeper) SetParams(ctx sdk.Context, params types.Params) { k.paramstore.SetParamSet(ctx, ¶ms) + k.ActivePairsStore().SetMany( + ctx, params.Pairs, true) } -// GetPairs returns the markets from params -func (k Keeper) GetPairs(ctx sdk.Context) types.Pairs { - return k.GetParams(ctx).Pairs +// GetPairs returns the pairs from params +func (k Keeper) GetPairs(ctx sdk.Context) common.AssetPairs { + var pairs common.AssetPairs + for _, pair := range k.GetParams(ctx).Pairs { + pairs = append(pairs, pair) + } + return pairs } -// GetOracles returns the oracles in the pricefeed store -func (k Keeper) GetOracles(ctx sdk.Context, pairID string) ([]sdk.AccAddress, error) { - for _, m := range k.GetPairs(ctx) { - if pairID == m.PairID() { - return m.Oracles, nil - } - } - return nil, sdkerrors.Wrap(types.ErrInvalidPair, pairID) +// GetOraclesForPair returns the oracles for a valid asset pair +func (k Keeper) GetOraclesForPair(ctx sdk.Context, pairID string, +) (oracles []sdk.AccAddress) { + pair := common.MustNewAssetPair(pairID) + return k.OraclesStore().Get(ctx, pair) } -// GetOracle returns the oracle from the store or an error if not found -func (k Keeper) GetOracle( +// IsWhitelistedOracle returns true if the address is whitelisted, false if not. +func (k Keeper) IsWhitelistedOracle( ctx sdk.Context, pairID string, address sdk.AccAddress, -) (sdk.AccAddress, error) { - oracles, err := k.GetOracles(ctx, pairID) - if err != nil { - // Error already wrapped - return nil, err - } +) bool { + pair := common.MustNewAssetPair(pairID) + oracles := k.OraclesStore().Get(ctx, pair) for _, addr := range oracles { if addr.Equals(address) { - return addr, nil + return true } } - return nil, sdkerrors.Wrap(types.ErrInvalidOracle, address.String()) + return false } // GetPair returns the market if it is in the pricefeed system -func (k Keeper) GetPair(ctx sdk.Context, pairID string) (types.Pair, bool) { - markets := k.GetPairs(ctx) +func (k Keeper) IsActivePair(ctx sdk.Context, pairID string) bool { + pair := common.MustNewAssetPair(pairID) + return k.ActivePairsStore().Get(ctx, pair) +} - for i := range markets { - if markets[i].PairID() == pairID { - return markets[i], true - } +// GetOraclesForPairs returns the 'oraclesMatrix' corresponding to 'pairs'. +// 'oraclesMap' is a map from pair → list of oracles. +// This function effectively gives a subset of the OraclesState KVStore. +func (k Keeper) GetOraclesForPairs(ctx sdk.Context, pairs common.AssetPairs, +) map[common.AssetPair][]sdk.AccAddress { + oraclesMap := make(map[common.AssetPair][]sdk.AccAddress) + for _, pair := range pairs { + oraclesMap[pair] = k.GetOraclesForPair(ctx, pair.String()) } - return types.Pair{}, false + return oraclesMap } -// GetAuthorizedAddresses returns a list of addresses that have special authorization within this module, eg the oracles of all markets. -func (k Keeper) GetAuthorizedAddresses(ctx sdk.Context) []sdk.AccAddress { - var oracles []sdk.AccAddress - uniqueOracles := map[string]bool{} +// Whitelists given 'oracles' for all of the current pairs in the module params. +func (k Keeper) WhitelistOracles(ctx sdk.Context, oracles []sdk.AccAddress) { + startParams := k.GetParams(ctx) + for _, pair := range startParams.Pairs { + k.addOraclesForPair(ctx, pair, oracles) + } +} - for _, m := range k.GetPairs(ctx) { - for _, o := range m.Oracles { - // de-dup list of oracles - if _, found := uniqueOracles[o.String()]; !found { - oracles = append(oracles, o) - } - uniqueOracles[o.String()] = true +// addOraclesForPair returns a 'newPair', which has an Oracles field formed by +// the unique set union of 'oracles' and 'pair.Oracles'. +func (k Keeper) addOraclesForPair( + ctx sdk.Context, pair common.AssetPair, oracles []sdk.AccAddress, +) (endingOracles []sdk.AccAddress) { + startingOracles := k.OraclesStore().Get(ctx, pair) + uniquePairOracles := make(map[string]bool) + for _, oracle := range append(startingOracles, oracles...) { + if _, found := uniquePairOracles[(oracle.String())]; !found { + endingOracles = append(endingOracles, oracle) + uniquePairOracles[oracle.String()] = true } } - return oracles + k.OraclesStore().Set(ctx, pair, endingOracles) + return endingOracles } -// Whitelists given 'oracles' for all of the current pairs. -func (k Keeper) WhitelistOracles(ctx sdk.Context, oracles []sdk.AccAddress) { - startParams := k.GetParams(ctx) - var endPairs types.Pairs - for _, pair := range startParams.Pairs { - var pairOracles []sdk.AccAddress - uniquePairOracles := make(map[string]bool) - for _, o := range append(pair.Oracles, oracles...) { - if _, found := uniquePairOracles[(o.String())]; !found { - pairOracles = append(pairOracles, o) - uniquePairOracles[o.String()] = true - } +// WhitelistOracleForPairs whitelists 'oracles' for the given 'pairs'. +func (k Keeper) WhitelistOraclesForPairs( + ctx sdk.Context, oracles []sdk.AccAddress, proposedPairs []common.AssetPair, +) { + paramsPairs := k.GetPairs(ctx) + + newPairs := []common.AssetPair{} + for _, pair := range proposedPairs { + pairIDBytes := []byte(pair.String()) + if !k.OraclesStore().getKV(ctx).Has(pairIDBytes) { + newPairs = append(newPairs, pair) } - endPairs = append(endPairs, - types.Pair{Token0: pair.Token0, Token1: pair.Token1, - Oracles: pairOracles, Active: pair.Active}) + + k.OraclesStore().AddOracles(ctx, pair, oracles) } - endParams := types.NewParams(endPairs) - k.SetParams(ctx, endParams) + endingPairs := append(paramsPairs, newPairs...) + k.SetParams(ctx, types.NewParams(endingPairs)) } diff --git a/x/pricefeed/keeper/params_test.go b/x/pricefeed/keeper/params_test.go index 0a020510b..02447368f 100644 --- a/x/pricefeed/keeper/params_test.go +++ b/x/pricefeed/keeper/params_test.go @@ -6,9 +6,12 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" + + "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/pricefeed/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestGetParams(t *testing.T) { @@ -19,7 +22,7 @@ func TestGetParams(t *testing.T) { { name: "calling GetParams without setting returns default", test: func() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) k := nibiruApp.PricefeedKeeper require.EqualValues(t, types.DefaultParams(), k.GetParams(ctx)) }, @@ -27,13 +30,10 @@ func TestGetParams(t *testing.T) { { name: "params match after manual set and include default", test: func() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) k := nibiruApp.PricefeedKeeper params := types.Params{ - Pairs: []types.Pair{ - {Token1: "btc", Token0: "usd", Oracles: nil, Active: true}, - {Token1: "xrp", Token0: "usd", Oracles: nil, Active: true}, - }, + Pairs: common.NewAssetPairs("btc:usd", "xrp:usd"), } k.SetParams(ctx, params) require.EqualValues(t, params, k.GetParams(ctx)) @@ -54,8 +54,6 @@ func TestGetParams(t *testing.T) { } func TestWhitelistOracles(t *testing.T) { - var noOracles []sdk.AccAddress - testCases := []struct { name string test func() @@ -63,42 +61,44 @@ func TestWhitelistOracles(t *testing.T) { { name: "genesis - no oracle provided", test: func() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) pk := &nibiruApp.PricefeedKeeper oracle := sample.AccAddress() - for _, pair := range pk.GetPairs(ctx) { - require.NotContains(t, pair.Oracles, oracle) - require.EqualValues(t, pair.Oracles, noOracles) + paramsPairs := pk.GetParams(ctx).Pairs + for _, pair := range paramsPairs { + require.False(t, pk.IsWhitelistedOracle(ctx, pair.String(), oracle)) } - require.EqualValues(t, - pk.GetAuthorizedAddresses(ctx), noOracles) + gotOraclesMap := pk.GetOraclesForPairs(ctx, paramsPairs) + gotOracles := gotOraclesMap[paramsPairs[0]] + require.EqualValues(t, []sdk.AccAddress(nil), gotOracles) }, }, { name: "multiple oracles whitelisted at different times ", test: func() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) pk := &nibiruApp.PricefeedKeeper - for _, pair := range pk.GetPairs(ctx) { - require.EqualValues(t, pair.Oracles, noOracles) + paramsPairs := pk.GetParams(ctx).Pairs + for _, pair := range paramsPairs { + require.EqualValues(t, []sdk.AccAddress(nil), pk.GetOraclesForPair(ctx, pair.String())) } - require.EqualValues(t, - pk.GetAuthorizedAddresses(ctx), noOracles) oracleA := sample.AccAddress() oracleB := sample.AccAddress() wantOracles := []sdk.AccAddress{oracleA} pk.WhitelistOracles(ctx, wantOracles) - gotOracles := pk.GetAuthorizedAddresses(ctx) + gotOraclesMap := pk.GetOraclesForPairs(ctx, paramsPairs) + gotOracles := gotOraclesMap[paramsPairs[0]] require.EqualValues(t, wantOracles, gotOracles) require.NotContains(t, gotOracles, oracleB) wantOracles = []sdk.AccAddress{oracleA, oracleB} pk.WhitelistOracles(ctx, wantOracles) - gotOracles = pk.GetAuthorizedAddresses(ctx) + gotOraclesMap = pk.GetOraclesForPairs(ctx, paramsPairs) + gotOracles = gotOraclesMap[paramsPairs[0]] require.EqualValues(t, wantOracles, gotOracles) }, }, @@ -112,3 +112,52 @@ func TestWhitelistOracles(t *testing.T) { ) } } + +func TestWhitelistOraclesForPairs(t *testing.T) { + testCases := []struct { + name string + startParams types.Params + pairsToSet common.AssetPairs + endAssetPairs common.AssetPairs + }{ + { + name: "whitelist for specific pairs - happy", + startParams: types.Params{ + Pairs: common.NewAssetPairs("aaa:usd", "bbb:usd", "oraclepair:usd"), + }, + pairsToSet: common.NewAssetPairs("oraclepair:usd"), + }, + } + + for _, testCase := range testCases { + tc := testCase + t.Run(tc.name, func(t *testing.T) { + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) + pricefeedKeeper := &nibiruApp.PricefeedKeeper + pricefeedKeeper.SetParams(ctx, tc.startParams) + + oracles := []sdk.AccAddress{sample.AccAddress(), sample.AccAddress()} + pricefeedKeeper.WhitelistOraclesForPairs( + ctx, + oracles, + /* pairs */ tc.pairsToSet, + ) + + t.Log("Verify that all 'pairsToSet' have the oracle set.") + for _, pair := range tc.pairsToSet { + assert.EqualValues(t, + oracles, + pricefeedKeeper.GetOraclesForPair(ctx, pair.String())) + } + + t.Log("Verify that all pairs outside 'pairsToSet' are unaffected.") + for _, pair := range tc.startParams.Pairs { + if !tc.pairsToSet.Contains(pair) { + assert.EqualValues(t, + []sdk.AccAddress{}, + pricefeedKeeper.GetOraclesForPair(ctx, pair.String())) + } + } + }) + } +} diff --git a/x/pricefeed/keeper/store.go b/x/pricefeed/keeper/store.go new file mode 100644 index 000000000..b00c7c654 --- /dev/null +++ b/x/pricefeed/keeper/store.go @@ -0,0 +1,162 @@ +package keeper + +import ( + "github.com/cosmos/cosmos-sdk/store/prefix" + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/NibiruChain/nibiru/x/common" + "github.com/NibiruChain/nibiru/x/pricefeed/types" +) + +// OraclesStore maintains the "oracles" KVStore: maps pair name → oracles. +func (k Keeper) OraclesStore() OraclesState { + return (OraclesState)(k) +} + +// ActivePairsStore maintains the "active pairs" KVStore: maps pair name → isActive. +// If a pair doesn't have a key in the store, the pair is inactive. +func (k Keeper) ActivePairsStore() ActivePairsState { + return (ActivePairsState)(k) +} + +//----------------------------------------------------------------------------- +// OraclesState implements methods for updating the "oracles" sdk.KVStore +type OraclesState Keeper + +var oraclesNamespace = []byte("oracles") + +func (state OraclesState) getKV(ctx sdk.Context) sdk.KVStore { + return prefix.NewStore(ctx.KVStore(state.storeKey), oraclesNamespace) +} + +func (state OraclesState) Get( + ctx sdk.Context, pair common.AssetPair, +) (oracles []sdk.AccAddress) { + kvStore := state.getKV(ctx) + key := []byte(pair.String()) + valueBytes := kvStore.Get(key) + if valueBytes == nil { + return []sdk.AccAddress{} + } + + oraclesMarshaler := &types.OraclesMarshaler{} + state.cdc.MustUnmarshal( + /*bytes=*/ valueBytes, + /*codec.ProtoMarshaler=*/ oraclesMarshaler) + + return oraclesMarshaler.Oracles +} + +func (state OraclesState) Set( + ctx sdk.Context, pair common.AssetPair, oracles []sdk.AccAddress, +) { + key := []byte(pair.String()) + kvStore := state.getKV(ctx) + oraclesMarshaler := &types.OraclesMarshaler{Oracles: oracles} + kvStore.Set(key, state.cdc.MustMarshal(oraclesMarshaler)) +} + +func (state OraclesState) AddOracles( + ctx sdk.Context, pair common.AssetPair, oracles []sdk.AccAddress, +) { + startOracles := state.Get(ctx, pair) + endOracles := append(startOracles, oracles...) + state.Set(ctx, pair, endOracles) +} + +func (state OraclesState) Iterate( + ctx sdk.Context, + do func(*types.OraclesMarshaler) (stop bool), +) { + kvStore := state.getKV(ctx) + iter := kvStore.Iterator(nil, nil) + defer iter.Close() + + for ; iter.Valid(); iter.Next() { + oraclesMarshaler := &types.OraclesMarshaler{} + state.cdc.MustUnmarshal(iter.Value(), oraclesMarshaler) + if !do(oraclesMarshaler) { + break + } + } +} + +//----------------------------------------------------------------------------- +// ActivePairsState implements methods for updating the "active pairs" sdk.KVStore +type ActivePairsState Keeper + +var activePairsNamespace = []byte("active pairs") + +func (state ActivePairsState) getKV(ctx sdk.Context) sdk.KVStore { + return prefix.NewStore(ctx.KVStore(state.storeKey), activePairsNamespace) +} + +func (state ActivePairsState) Get( + ctx sdk.Context, pair common.AssetPair, +) (active bool) { + kvStore := state.getKV(ctx) + key := []byte(pair.String()) + valueBytes := kvStore.Get(key) + if valueBytes == nil { + return false + } + + activePairsMarshaler := &types.ActivePairMarshaler{} + state.cdc.MustUnmarshal( + /*bytes=*/ valueBytes, + /*codec.ProtoMarshaler=*/ activePairsMarshaler) + + isActive := activePairsMarshaler.IsActive + if (valueBytes != nil) && !isActive { + kvStore.Delete(key) + } + return isActive +} + +/* ActivePairsState.Set either sets a pair to active or deletes it from the +key-value store (i.e., pairs default to inactive if they don't exist). */ +func (state ActivePairsState) Set( + ctx sdk.Context, pair common.AssetPair, active bool, +) { + key := []byte(pair.String()) + kvStore := state.getKV(ctx) + if active { + activePairsMarshaler := &types.ActivePairMarshaler{IsActive: active} + kvStore.Set(key, state.cdc.MustMarshal(activePairsMarshaler)) + } else if !active && kvStore.Has(key) { + kvStore.Delete(key) + } // else {do nothing} +} + +func (state ActivePairsState) SetMany( + ctx sdk.Context, pairs common.AssetPairs, active bool, +) { + for _, pair := range pairs { + state.Set(ctx, pair, active) + } +} + +func (state ActivePairsState) AddActivePairs( + ctx sdk.Context, pairs []common.AssetPair, +) { + for _, pair := range pairs { + state.Set(ctx, pair, true) + } +} + +func (state ActivePairsState) Iterate( + ctx sdk.Context, + do func(*types.ActivePairMarshaler) (stop bool), +) { + kvStore := state.getKV(ctx) + iter := kvStore.Iterator(nil, nil) + defer iter.Close() + + for ; iter.Valid(); iter.Next() { + activePairsMarshaler := &types.ActivePairMarshaler{} + state.cdc.MustUnmarshal(iter.Value(), activePairsMarshaler) + if !do(activePairsMarshaler) { + break + } + } +} diff --git a/x/pricefeed/module.go b/x/pricefeed/module.go index 3e03f0d6a..98da84a35 100644 --- a/x/pricefeed/module.go +++ b/x/pricefeed/module.go @@ -5,8 +5,6 @@ import ( "encoding/json" "fmt" - // this line is used by starport scaffolding # 1 - "github.com/gorilla/mux" "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/spf13/cobra" @@ -80,7 +78,6 @@ func (AppModuleBasic) RegisterRESTRoutes(clientCtx client.Context, rtr *mux.Rout // RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the module. func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux) { - // this line is used by starport scaffolding # 2 if err := types.RegisterQueryHandlerClient(context.Background(), mux, types.NewQueryClient(clientCtx)); err != nil { panic(err) } diff --git a/x/pricefeed/module_simulation.go b/x/pricefeed/module_simulation.go index 246fc5823..6fd87535a 100644 --- a/x/pricefeed/module_simulation.go +++ b/x/pricefeed/module_simulation.go @@ -28,8 +28,6 @@ const ( opWeightMsgPostPrice = "op_weight_msg_create_chain" // TODO: Determine the simulation weight value defaultWeightMsgPostPrice int = 100 - - // this line is used by starport scaffolding # simapp/module/const ) // GenerateGenesisState creates a randomized GenState of the module @@ -38,9 +36,7 @@ func (AppModule) GenerateGenesisState(simState *module.SimulationState) { for i, acc := range simState.Accounts { accs[i] = acc.Address.String() } - pricefeedGenesis := types.GenesisState{ - // this line is used by starport scaffolding # simapp/module/genesisState - } + pricefeedGenesis := types.GenesisState{} simState.GenState[types.ModuleName] = simState.Cdc.MustMarshalJSON(&pricefeedGenesis) } @@ -72,7 +68,5 @@ func (am AppModule) WeightedOperations(simState module.SimulationState) []simtyp pricefeedsimulation.SimulateMsgPostPrice(am.accountKeeper, am.bankKeeper, am.keeper), )) - // this line is used by starport scaffolding # simapp/module/operation - return operations } diff --git a/x/pricefeed/types/codec.go b/x/pricefeed/types/codec.go index c11a2ff4a..254330fd8 100644 --- a/x/pricefeed/types/codec.go +++ b/x/pricefeed/types/codec.go @@ -9,14 +9,13 @@ import ( func RegisterCodec(cdc *codec.LegacyAmino) { cdc.RegisterConcrete(&MsgPostPrice{}, "pricefeed/PostPrice", nil) - // this line is used by starport scaffolding # 2 } func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { - registry.RegisterImplementations((*sdk.Msg)(nil), + registry.RegisterImplementations( + /* interface */ (*sdk.Msg)(nil), &MsgPostPrice{}, ) - // this line is used by starport scaffolding # 3 msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) } diff --git a/x/pricefeed/types/genesis.go b/x/pricefeed/types/genesis.go index d973f099b..140b24ae2 100644 --- a/x/pricefeed/types/genesis.go +++ b/x/pricefeed/types/genesis.go @@ -1,6 +1,12 @@ package types -// this line is used by starport scaffolding # genesis/types/import +import ( + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/NibiruChain/nibiru/x/common" +) // DefaultIndex is the default capability global index const DefaultIndex uint64 = 1 @@ -8,27 +14,43 @@ const DefaultIndex uint64 = 1 // DefaultGenesis returns the default Capability genesis state func DefaultGenesis() *GenesisState { return &GenesisState{ - // this line is used by starport scaffolding # genesis/types/default Params: DefaultParams(), PostedPrices: []PostedPrice{}, } } // NewGenesisState creates a new genesis state for the pricefeed module -func NewGenesisState(p Params, pp []PostedPrice) *GenesisState { +func NewGenesisState(p Params, postedPrices []PostedPrice) *GenesisState { + var oracles []string + for _, postedPrice := range postedPrices { + oracle := sdk.MustAccAddressFromBech32(postedPrice.Oracle) + oracles = append(oracles, oracle.String()) + } return &GenesisState{ - Params: p, - PostedPrices: pp, + Params: p, + PostedPrices: postedPrices, + GenesisOracles: oracles, } } // Validate performs basic genesis state validation returning an error upon any // failure. func (gs GenesisState) Validate() error { - // this line is used by starport scaffolding # genesis/types/validate if err := gs.Params.Validate(); err != nil { return err } + if err := gs.PostedPrices.Validate(); err != nil { + return err + } + + var pairs common.AssetPairs = gs.Params.Pairs // needed for Contains method + for _, postedPrice := range gs.PostedPrices { + if !pairs.Contains(common.MustNewAssetPair(postedPrice.PairID)) { + return fmt.Errorf( + "pair of posted price, %s, which must be in the genesis params", + postedPrice.PairID) + } + } - return gs.PostedPrices.Validate() + return nil } diff --git a/x/pricefeed/types/genesis.pb.go b/x/pricefeed/types/genesis.pb.go index 668f1f27d..50c7c82cc 100644 --- a/x/pricefeed/types/genesis.pb.go +++ b/x/pricefeed/types/genesis.pb.go @@ -26,8 +26,9 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // GenesisState defines the pricefeed module's genesis state. type GenesisState struct { // params defines all the paramaters of the module. - Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` - PostedPrices PostedPrices `protobuf:"bytes,2,rep,name=posted_prices,json=postedPrices,proto3,castrepeated=PostedPrices" json:"posted_prices"` + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + PostedPrices PostedPrices `protobuf:"bytes,2,rep,name=posted_prices,json=postedPrices,proto3,castrepeated=PostedPrices" json:"posted_prices"` + GenesisOracles []string `protobuf:"bytes,3,rep,name=genesis_oracles,json=genesisOracles,proto3" json:"genesis_oracles,omitempty"` } func (m *GenesisState) Reset() { *m = GenesisState{} } @@ -77,30 +78,38 @@ func (m *GenesisState) GetPostedPrices() PostedPrices { return nil } +func (m *GenesisState) GetGenesisOracles() []string { + if m != nil { + return m.GenesisOracles + } + return nil +} + func init() { - proto.RegisterType((*GenesisState)(nil), "NibiruChain.pricefeed.v1.GenesisState") + proto.RegisterType((*GenesisState)(nil), "nibiru.pricefeed.v1.GenesisState") } func init() { proto.RegisterFile("pricefeed/genesis.proto", fileDescriptor_e33b22b561d44d2b) } var fileDescriptor_e33b22b561d44d2b = []byte{ - // 244 bytes of a gzipped FileDescriptorProto + // 271 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2f, 0x28, 0xca, 0x4c, 0x4e, 0x4d, 0x4b, 0x4d, 0x4d, 0xd1, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, - 0xca, 0x2f, 0xc9, 0x17, 0x92, 0xf0, 0xcb, 0x4c, 0xca, 0x2c, 0x2a, 0x75, 0xce, 0x48, 0xcc, 0xcc, - 0xd3, 0x83, 0x2b, 0xd2, 0x2b, 0x33, 0x94, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0x2b, 0xd2, 0x07, - 0xb1, 0x20, 0xea, 0xa5, 0xc4, 0x10, 0x06, 0x15, 0x24, 0x16, 0x25, 0xe6, 0x42, 0xcd, 0x51, 0xda, - 0xc0, 0xc8, 0xc5, 0xe3, 0x0e, 0x31, 0x39, 0xb8, 0x24, 0xb1, 0x24, 0x55, 0xc8, 0x8e, 0x8b, 0x0d, - 0xa2, 0x40, 0x82, 0x51, 0x81, 0x51, 0x83, 0xdb, 0x48, 0x41, 0x0f, 0x97, 0x4d, 0x7a, 0x01, 0x60, - 0x75, 0x4e, 0x2c, 0x27, 0xee, 0xc9, 0x33, 0x04, 0x41, 0x75, 0x09, 0x25, 0x70, 0xf1, 0x16, 0xe4, - 0x17, 0x97, 0xa4, 0xa6, 0xc4, 0x83, 0xd5, 0x16, 0x4b, 0x30, 0x29, 0x30, 0x6b, 0x70, 0x1b, 0xa9, - 0xe2, 0x31, 0x06, 0xac, 0x3c, 0x00, 0x24, 0xe4, 0x24, 0x02, 0x32, 0x6b, 0xd5, 0x7d, 0x79, 0x1e, - 0x24, 0xc1, 0xe2, 0x20, 0x9e, 0x02, 0x24, 0x9e, 0x93, 0xe7, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, - 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, - 0x1e, 0xcb, 0x31, 0x44, 0xe9, 0xa7, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, - 0x23, 0x59, 0xa7, 0x9f, 0x07, 0x66, 0xeb, 0x57, 0xe8, 0x23, 0x02, 0xa1, 0xa4, 0xb2, 0x20, 0xb5, - 0x38, 0x89, 0x0d, 0x1c, 0x08, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x9b, 0xbf, 0x11, 0xf7, - 0x67, 0x01, 0x00, 0x00, + 0xca, 0x2f, 0xc9, 0x17, 0x12, 0xce, 0xcb, 0x4c, 0xca, 0x2c, 0x2a, 0xd5, 0x83, 0xcb, 0xeb, 0x95, + 0x19, 0x4a, 0x89, 0xa4, 0xe7, 0xa7, 0xe7, 0x83, 0xe5, 0xf5, 0x41, 0x2c, 0x88, 0x52, 0x29, 0x31, + 0x84, 0x19, 0x05, 0x89, 0x45, 0x89, 0xb9, 0x50, 0x23, 0x94, 0xce, 0x33, 0x72, 0xf1, 0xb8, 0x43, + 0x0c, 0x0d, 0x2e, 0x49, 0x2c, 0x49, 0x15, 0xb2, 0xe4, 0x62, 0x83, 0x28, 0x90, 0x60, 0x54, 0x60, + 0xd4, 0xe0, 0x36, 0x92, 0xd6, 0xc3, 0x62, 0x89, 0x5e, 0x00, 0x58, 0x89, 0x13, 0xcb, 0x89, 0x7b, + 0xf2, 0x0c, 0x41, 0x50, 0x0d, 0x42, 0xd1, 0x5c, 0xbc, 0x05, 0xf9, 0xc5, 0x25, 0xa9, 0x29, 0xf1, + 0x60, 0xb5, 0xc5, 0x12, 0x4c, 0x0a, 0xcc, 0x1a, 0xdc, 0x46, 0x0a, 0xd8, 0x4d, 0x00, 0xab, 0x0c, + 0x00, 0x09, 0x39, 0x89, 0x80, 0x8c, 0x59, 0x75, 0x5f, 0x9e, 0x07, 0x49, 0xb0, 0x38, 0x88, 0xa7, + 0x00, 0x89, 0x27, 0xa4, 0xce, 0xc5, 0x0f, 0xf5, 0x7c, 0x7c, 0x7e, 0x51, 0x62, 0x72, 0x4e, 0x6a, + 0xb1, 0x04, 0xb3, 0x02, 0xb3, 0x06, 0x67, 0x10, 0x1f, 0x54, 0xd8, 0x1f, 0x22, 0xea, 0xe4, 0x79, + 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x4e, 0x78, 0x2c, 0xc7, + 0x70, 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0xfa, 0xe9, 0x99, 0x25, 0x19, 0xa5, + 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x7e, 0x60, 0x27, 0x39, 0x67, 0x24, 0x66, 0xe6, 0xe9, 0x43, + 0x9c, 0xa7, 0x5f, 0xa1, 0x8f, 0x08, 0xa3, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0x70, 0x18, + 0x19, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x0b, 0x4d, 0xa4, 0x42, 0x81, 0x01, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -123,6 +132,15 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.GenesisOracles) > 0 { + for iNdEx := len(m.GenesisOracles) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.GenesisOracles[iNdEx]) + copy(dAtA[i:], m.GenesisOracles[iNdEx]) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.GenesisOracles[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } if len(m.PostedPrices) > 0 { for iNdEx := len(m.PostedPrices) - 1; iNdEx >= 0; iNdEx-- { { @@ -175,6 +193,12 @@ func (m *GenesisState) Size() (n int) { n += 1 + l + sovGenesis(uint64(l)) } } + if len(m.GenesisOracles) > 0 { + for _, s := range m.GenesisOracles { + l = len(s) + n += 1 + l + sovGenesis(uint64(l)) + } + } return n } @@ -280,6 +304,38 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GenesisOracles", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GenesisOracles = append(m.GenesisOracles, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenesis(dAtA[iNdEx:]) diff --git a/x/pricefeed/types/genesis_test.go b/x/pricefeed/types/genesis_test.go deleted file mode 100644 index 22ccec881..000000000 --- a/x/pricefeed/types/genesis_test.go +++ /dev/null @@ -1,76 +0,0 @@ -package types - -import ( - "testing" - "time" - - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/stretchr/testify/require" - tmtypes "github.com/tendermint/tendermint/types" -) - -func TestGenesisState_Validate(t *testing.T) { - mockPrivKey := tmtypes.NewMockPV() - pubkey, err := mockPrivKey.GetPubKey() - require.NoError(t, err) - addr := sdk.AccAddress(pubkey.Address()) - now := time.Now() - - for _, tc := range []struct { - desc string - genState *GenesisState - valid bool - }{ - { - desc: "default is valid", - genState: DefaultGenesis(), - valid: true, - }, - { - desc: "valid genesis state", - genState: &GenesisState{}, - valid: true, - }, - { - desc: "dup market param", - genState: NewGenesisState( - NewParams([]Pair{ - {"xrp", "bnb", []sdk.AccAddress{addr}, true}, - {"xrp", "bnb", []sdk.AccAddress{addr}, true}, - }), - []PostedPrice{NewPostedPrice("xrp", addr, sdk.OneDec(), now)}, - ), - valid: false, - }, - { - desc: "invalid posted price", - genState: NewGenesisState( - NewParams([]Pair{}), - []PostedPrice{NewPostedPrice("xrp", nil, sdk.OneDec(), now)}, - ), - valid: false, - }, - { - desc: "duplicated posted price", - genState: NewGenesisState( - NewParams([]Pair{}), - []PostedPrice{ - NewPostedPrice("xrp", addr, sdk.OneDec(), now), - NewPostedPrice("xrp", addr, sdk.OneDec(), now), - }, - ), - valid: false, - }, - - // this line is used by starport scaffolding # types/genesis/testcase - } { - t.Run(tc.desc, func(t *testing.T) { - err := tc.genState.Validate() - if tc.valid { - require.NoError(t, err) - } else { - require.Error(t, err) - } - }) - } -} diff --git a/x/pricefeed/types/market.go b/x/pricefeed/types/market.go index dc8795da8..c3fe2db7f 100644 --- a/x/pricefeed/types/market.go +++ b/x/pricefeed/types/market.go @@ -11,101 +11,20 @@ import ( "github.com/NibiruChain/nibiru/x/common" ) -func (pair Pair) PairID() string { - return common.PoolNameFromDenoms([]string{pair.Token0, pair.Token1}) -} - -// NewPair returns a new Pair -func NewPair( - token0 string, token1 string, oracles []sdk.AccAddress, active bool, -) Pair { - return Pair{ - Token0: token0, - Token1: token1, - Oracles: oracles, - Active: active, - } -} - -// name is the name of the pool that corresponds to the two assets on this pair. -func (pair Pair) Name() string { - assets := common.AssetPair{Token0: pair.Token0, Token1: pair.Token1} - return assets.Name() -} - -func (pair Pair) AsString() string { - return fmt.Sprintf("%s:%s", pair.Token0, pair.Token1) -} - -func (pair Pair) IsProperOrder() bool { - assets := common.AssetPair{Token0: pair.Token0, Token1: pair.Token1} - return assets.IsProperOrder() -} - -func (pair Pair) Inverse() Pair { - return Pair{pair.Token1, pair.Token0, pair.Oracles, pair.Active} -} - -// Validate performs a basic validation of the market params -func (m Pair) Validate() error { - if strings.TrimSpace(m.PairID()) == "" { - return errors.New("market id cannot be blank") - } - if err := sdk.ValidateDenom(m.Token1); err != nil { - return fmt.Errorf("invalid token1 asset: %w", err) - } - if err := sdk.ValidateDenom(m.Token0); err != nil { - return fmt.Errorf("invalid token0 asset: %w", err) - } - seenOracles := make(map[string]bool) - for i, oracle := range m.Oracles { - if len(oracle) == 0 { - return fmt.Errorf("oracle %d is empty", i) - } - if seenOracles[oracle.String()] { - return fmt.Errorf("duplicated oracle %s", oracle) - } - seenOracles[oracle.String()] = true - } - return nil -} - -// ToPairResponse returns a new PairResponse from a Pair -func (m Pair) ToPairResponse() PairResponse { - return NewPairResponse(m.Token1, m.Token0, m.Oracles, m.Active) -} - -// Pairs is a slice of Pair -type Pairs []Pair - -// Validate checks if all the markets are valid and there are no duplicated entries. -func (ms Pairs) Validate() error { - seenPairs := make(map[string]bool) - for _, m := range ms { - pairID := common.PoolNameFromDenoms([]string{m.Token0, m.Token1}) - if seenPairs[pairID] { - return fmt.Errorf("duplicated market %s", pairID) - } - if err := m.Validate(); err != nil { - return err - } - seenPairs[pairID] = true - } - return nil -} - // NewPairResponse returns a new PairResponse -func NewPairResponse(token1 string, token0 string, oracles []sdk.AccAddress, active bool) PairResponse { +func NewPairResponse(pair common.AssetPair, oracles []sdk.AccAddress, active bool) PairResponse { + if err := pair.Validate(); err != nil { + panic(err) + } var strOracles []string for _, oracle := range oracles { strOracles = append(strOracles, oracle.String()) } - pairID := common.PoolNameFromDenoms([]string{token0, token1}) return PairResponse{ - PairID: pairID, - Token1: token1, - Token0: token0, + PairID: pair.String(), + Token1: pair.Token1, + Token0: pair.Token0, Oracles: strOracles, Active: active, } @@ -126,7 +45,7 @@ Returns: */ func NewCurrentPrice(token0 string, token1 string, price sdk.Dec) CurrentPrice { assetPair := common.AssetPair{Token0: token0, Token1: token1} - return CurrentPrice{PairID: assetPair.Name(), Price: price} + return CurrentPrice{PairID: assetPair.String(), Price: price} } /* @@ -141,7 +60,7 @@ Returns: */ func NewCurrentTWAP(token0 string, token1 string, numerator sdk.Dec, denominator sdk.Dec, price sdk.Dec) CurrentTWAP { assetPair := common.AssetPair{Token0: token0, Token1: token1} - return CurrentTWAP{PairID: assetPair.Name(), Numerator: numerator, Denominator: denominator, Price: price} + return CurrentTWAP{PairID: assetPair.String(), Numerator: numerator, Denominator: denominator, Price: price} } // CurrentPrices is a slice of CurrentPrice @@ -156,12 +75,13 @@ func NewCurrentPriceResponse(pairID string, price sdk.Dec) CurrentPriceResponse type CurrentPriceResponses []CurrentPriceResponse // NewPostedPrice returns a new PostedPrice -func NewPostedPrice(pairID string, oracle sdk.AccAddress, price sdk.Dec, expiry time.Time) PostedPrice { +func NewPostedPrice(pair common.AssetPair, oracle sdk.AccAddress, price sdk.Dec, expiry time.Time, +) PostedPrice { return PostedPrice{ - PairID: pairID, - OracleAddress: oracle, - Price: price, - Expiry: expiry, + PairID: pair.String(), + Oracle: oracle.String(), + Price: price, + Expiry: expiry, } } @@ -170,9 +90,15 @@ func (pp PostedPrice) Validate() error { if strings.TrimSpace(pp.PairID) == "" { return errors.New("market id cannot be blank") } - if len(pp.OracleAddress) == 0 { + if _, err := common.NewAssetPair(pp.PairID); err != nil { + return err + } + if len(pp.Oracle) == 0 { return errors.New("oracle address cannot be empty") } + if _, err := sdk.AccAddressFromBech32(pp.Oracle); err != nil { + return err + } if pp.Price.IsNegative() { return fmt.Errorf("posted price cannot be negative %s", pp.Price) } @@ -190,14 +116,14 @@ type PostedPrices []PostedPrice func (pps PostedPrices) Validate() error { seenPrices := make(map[string]bool) for _, pp := range pps { - if !pp.OracleAddress.Empty() && seenPrices[pp.PairID+pp.OracleAddress.String()] { - return fmt.Errorf("duplicated posted price for marked id %s and oracle address %s", pp.PairID, pp.OracleAddress) + if !(pp.Oracle == "") && seenPrices[pp.PairID+pp.Oracle] { + return fmt.Errorf("duplicated posted price for market id %s and oracle address %s", pp.PairID, pp.Oracle) } if err := pp.Validate(); err != nil { return err } - seenPrices[pp.PairID+pp.OracleAddress.String()] = true + seenPrices[pp.PairID+pp.Oracle] = true } return nil diff --git a/x/pricefeed/types/pair_test.go b/x/pricefeed/types/pair_test.go deleted file mode 100644 index 861bc4e81..000000000 --- a/x/pricefeed/types/pair_test.go +++ /dev/null @@ -1,43 +0,0 @@ -package types_test - -import ( - "testing" - - "github.com/stretchr/testify/require" - - "github.com/NibiruChain/nibiru/x/pricefeed/types" -) - -func TestPair(t *testing.T) { - testCases := []struct { - name string - pair types.Pair - proper bool - }{ - { - name: "proper and improper order pairs are inverses-1", - pair: types.NewPair("atom", "osmo", nil, true), - proper: true, - }, - { - name: "proper and improper order pairs are inverses-2", - pair: types.NewPair("osmo", "atom", nil, true), - proper: false, - }, - } - - for _, testCase := range testCases { - tc := testCase - t.Run(tc.name, func(t *testing.T) { - if tc.proper { - require.True(t, tc.pair.IsProperOrder()) - require.EqualValues(t, tc.pair.Name(), tc.pair.AsString()) - } else { - require.True(t, tc.pair.Inverse().IsProperOrder()) - require.EqualValues(t, tc.pair.Name(), tc.pair.Inverse().AsString()) - } - - require.True(t, true) - }) - } -} diff --git a/x/pricefeed/types/params.pb.go b/x/pricefeed/types/params.pb.go index bceeb896e..785a156f4 100644 --- a/x/pricefeed/types/params.pb.go +++ b/x/pricefeed/types/params.pb.go @@ -6,6 +6,7 @@ package types import ( bytes "bytes" fmt "fmt" + common "github.com/NibiruChain/nibiru/x/common" github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" @@ -30,9 +31,11 @@ var _ = time.Kitchen // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package -// Params defines the parameters for the module. +// Params defines the parameters for the x/pricefeed module. type Params struct { - Pairs Pairs `protobuf:"bytes,1,rep,name=pairs,proto3,castrepeated=Pairs" json:"pairs"` + // Pairs is the list of valid trading pairs for the module. + // Add new trading pairs + Pairs []common.AssetPair `protobuf:"bytes,1,rep,name=pairs,proto3" json:"pairs"` } func (m *Params) Reset() { *m = Params{} } @@ -68,33 +71,31 @@ func (m *Params) XXX_DiscardUnknown() { var xxx_messageInfo_Params proto.InternalMessageInfo -func (m *Params) GetPairs() Pairs { +func (m *Params) GetPairs() []common.AssetPair { if m != nil { return m.Pairs } return nil } -// Pair defines an asset in the pricefeed. -type Pair struct { - Token0 string `protobuf:"bytes,1,opt,name=token0,proto3" json:"token0,omitempty"` - Token1 string `protobuf:"bytes,2,opt,name=token1,proto3" json:"token1,omitempty"` - Oracles []github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,3,rep,name=oracles,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"oracles,omitempty"` - Active bool `protobuf:"varint,4,opt,name=active,proto3" json:"active,omitempty"` +// OraclesMarshaler is a codec.ProtoMarshaler for an oracles array in the +// OraclesState sdk.KVStore. +type OraclesMarshaler struct { + Oracles []github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,rep,name=oracles,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"oracles,omitempty"` } -func (m *Pair) Reset() { *m = Pair{} } -func (m *Pair) String() string { return proto.CompactTextString(m) } -func (*Pair) ProtoMessage() {} -func (*Pair) Descriptor() ([]byte, []int) { +func (m *OraclesMarshaler) Reset() { *m = OraclesMarshaler{} } +func (m *OraclesMarshaler) String() string { return proto.CompactTextString(m) } +func (*OraclesMarshaler) ProtoMessage() {} +func (*OraclesMarshaler) Descriptor() ([]byte, []int) { return fileDescriptor_76ce94fb65bc3a91, []int{1} } -func (m *Pair) XXX_Unmarshal(b []byte) error { +func (m *OraclesMarshaler) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *OraclesMarshaler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_Pair.Marshal(b, m, deterministic) + return xxx_messageInfo_OraclesMarshaler.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -104,59 +105,84 @@ func (m *Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *Pair) XXX_Merge(src proto.Message) { - xxx_messageInfo_Pair.Merge(m, src) +func (m *OraclesMarshaler) XXX_Merge(src proto.Message) { + xxx_messageInfo_OraclesMarshaler.Merge(m, src) } -func (m *Pair) XXX_Size() int { +func (m *OraclesMarshaler) XXX_Size() int { return m.Size() } -func (m *Pair) XXX_DiscardUnknown() { - xxx_messageInfo_Pair.DiscardUnknown(m) +func (m *OraclesMarshaler) XXX_DiscardUnknown() { + xxx_messageInfo_OraclesMarshaler.DiscardUnknown(m) } -var xxx_messageInfo_Pair proto.InternalMessageInfo +var xxx_messageInfo_OraclesMarshaler proto.InternalMessageInfo -func (m *Pair) GetToken0() string { +func (m *OraclesMarshaler) GetOracles() []github_com_cosmos_cosmos_sdk_types.AccAddress { if m != nil { - return m.Token0 + return m.Oracles } - return "" + return nil } -func (m *Pair) GetToken1() string { - if m != nil { - return m.Token1 - } - return "" +// ActivePairMarshaler is a codec.ProtoMarshaler for the "IsActive" status of +// a pair in the ActivePairState sdk.KVStore. +type ActivePairMarshaler struct { + IsActive bool `protobuf:"varint,1,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"` } -func (m *Pair) GetOracles() []github_com_cosmos_cosmos_sdk_types.AccAddress { - if m != nil { - return m.Oracles +func (m *ActivePairMarshaler) Reset() { *m = ActivePairMarshaler{} } +func (m *ActivePairMarshaler) String() string { return proto.CompactTextString(m) } +func (*ActivePairMarshaler) ProtoMessage() {} +func (*ActivePairMarshaler) Descriptor() ([]byte, []int) { + return fileDescriptor_76ce94fb65bc3a91, []int{2} +} +func (m *ActivePairMarshaler) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ActivePairMarshaler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ActivePairMarshaler.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return nil +} +func (m *ActivePairMarshaler) XXX_Merge(src proto.Message) { + xxx_messageInfo_ActivePairMarshaler.Merge(m, src) +} +func (m *ActivePairMarshaler) XXX_Size() int { + return m.Size() +} +func (m *ActivePairMarshaler) XXX_DiscardUnknown() { + xxx_messageInfo_ActivePairMarshaler.DiscardUnknown(m) } -func (m *Pair) GetActive() bool { +var xxx_messageInfo_ActivePairMarshaler proto.InternalMessageInfo + +func (m *ActivePairMarshaler) GetIsActive() bool { if m != nil { - return m.Active + return m.IsActive } return false } // PostedPrice defines a price for an asset pair posted by a specific oracle. type PostedPrice struct { - PairID string `protobuf:"bytes,1,opt,name=pair_id,json=pairId,proto3" json:"pair_id,omitempty"` - OracleAddress github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,2,opt,name=oracle_address,json=oracleAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"oracle_address,omitempty"` - Price github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=price,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"price"` - Expiry time.Time `protobuf:"bytes,4,opt,name=expiry,proto3,stdtime" json:"expiry"` + PairID string `protobuf:"bytes,1,opt,name=pair_id,json=pairId,proto3" json:"pair_id,omitempty"` + Oracle string `protobuf:"bytes,2,opt,name=oracle,proto3" json:"oracle,omitempty"` + Price github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=price,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"price"` + Expiry time.Time `protobuf:"bytes,4,opt,name=expiry,proto3,stdtime" json:"expiry"` } func (m *PostedPrice) Reset() { *m = PostedPrice{} } func (m *PostedPrice) String() string { return proto.CompactTextString(m) } func (*PostedPrice) ProtoMessage() {} func (*PostedPrice) Descriptor() ([]byte, []int) { - return fileDescriptor_76ce94fb65bc3a91, []int{2} + return fileDescriptor_76ce94fb65bc3a91, []int{3} } func (m *PostedPrice) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -192,11 +218,11 @@ func (m *PostedPrice) GetPairID() string { return "" } -func (m *PostedPrice) GetOracleAddress() github_com_cosmos_cosmos_sdk_types.AccAddress { +func (m *PostedPrice) GetOracle() string { if m != nil { - return m.OracleAddress + return m.Oracle } - return nil + return "" } func (m *PostedPrice) GetExpiry() time.Time { @@ -217,7 +243,7 @@ func (m *CurrentPrice) Reset() { *m = CurrentPrice{} } func (m *CurrentPrice) String() string { return proto.CompactTextString(m) } func (*CurrentPrice) ProtoMessage() {} func (*CurrentPrice) Descriptor() ([]byte, []int) { - return fileDescriptor_76ce94fb65bc3a91, []int{3} + return fileDescriptor_76ce94fb65bc3a91, []int{4} } func (m *CurrentPrice) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -265,7 +291,7 @@ func (m *CurrentTWAP) Reset() { *m = CurrentTWAP{} } func (m *CurrentTWAP) String() string { return proto.CompactTextString(m) } func (*CurrentTWAP) ProtoMessage() {} func (*CurrentTWAP) Descriptor() ([]byte, []int) { - return fileDescriptor_76ce94fb65bc3a91, []int{4} + return fileDescriptor_76ce94fb65bc3a91, []int{5} } func (m *CurrentTWAP) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -302,87 +328,53 @@ func (m *CurrentTWAP) GetPairID() string { } func init() { - proto.RegisterType((*Params)(nil), "NibiruChain.pricefeed.v1.Params") - proto.RegisterType((*Pair)(nil), "NibiruChain.pricefeed.v1.Pair") - proto.RegisterType((*PostedPrice)(nil), "NibiruChain.pricefeed.v1.PostedPrice") - proto.RegisterType((*CurrentPrice)(nil), "NibiruChain.pricefeed.v1.CurrentPrice") - proto.RegisterType((*CurrentTWAP)(nil), "NibiruChain.pricefeed.v1.CurrentTWAP") + proto.RegisterType((*Params)(nil), "nibiru.pricefeed.v1.Params") + proto.RegisterType((*OraclesMarshaler)(nil), "nibiru.pricefeed.v1.OraclesMarshaler") + proto.RegisterType((*ActivePairMarshaler)(nil), "nibiru.pricefeed.v1.ActivePairMarshaler") + proto.RegisterType((*PostedPrice)(nil), "nibiru.pricefeed.v1.PostedPrice") + proto.RegisterType((*CurrentPrice)(nil), "nibiru.pricefeed.v1.CurrentPrice") + proto.RegisterType((*CurrentTWAP)(nil), "nibiru.pricefeed.v1.CurrentTWAP") } func init() { proto.RegisterFile("pricefeed/params.proto", fileDescriptor_76ce94fb65bc3a91) } var fileDescriptor_76ce94fb65bc3a91 = []byte{ - // 518 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0xbb, 0x6e, 0xdb, 0x30, - 0x14, 0x35, 0xfd, 0x50, 0x12, 0x3a, 0xe9, 0x20, 0x14, 0x81, 0xea, 0x41, 0x32, 0x5c, 0xa0, 0xf0, - 0x12, 0xaa, 0x4e, 0xd7, 0x2e, 0x7e, 0x2c, 0x41, 0x1f, 0x50, 0x85, 0x00, 0x2d, 0xba, 0x18, 0xb4, - 0xc4, 0x38, 0x44, 0x22, 0x51, 0x20, 0xe9, 0x20, 0xfe, 0x0b, 0x8f, 0x05, 0xfa, 0x03, 0x45, 0xbf, - 0x24, 0x63, 0xc6, 0xa2, 0x83, 0x93, 0xca, 0x7f, 0xd1, 0xa9, 0x20, 0x29, 0x3f, 0x96, 0x02, 0x89, - 0x33, 0x89, 0xe7, 0xea, 0xde, 0x73, 0xce, 0xbd, 0x57, 0x22, 0x3c, 0xcc, 0x38, 0x8d, 0xc8, 0x19, - 0x21, 0xb1, 0x9f, 0x61, 0x8e, 0x13, 0x81, 0x32, 0xce, 0x24, 0xb3, 0x9d, 0x8f, 0x74, 0x44, 0xf9, - 0xa4, 0x7f, 0x8e, 0x69, 0x8a, 0x56, 0x39, 0xe8, 0xaa, 0xd3, 0x78, 0x11, 0x31, 0x91, 0x30, 0x31, - 0xd4, 0x79, 0xbe, 0x01, 0xa6, 0xa8, 0xf1, 0x7c, 0xcc, 0xc6, 0xcc, 0xc4, 0xd5, 0xa9, 0x88, 0x7a, - 0x63, 0xc6, 0xc6, 0x97, 0xc4, 0xd7, 0x68, 0x34, 0x39, 0xf3, 0x25, 0x4d, 0x88, 0x90, 0x38, 0xc9, - 0x4c, 0x42, 0xeb, 0x03, 0xb4, 0x02, 0xad, 0x6d, 0xf7, 0x61, 0x2d, 0xc3, 0x94, 0x0b, 0x07, 0x34, - 0x2b, 0xed, 0xfa, 0xb1, 0x8b, 0xfe, 0xe7, 0x02, 0x05, 0x98, 0xf2, 0xde, 0xc1, 0xcd, 0xdc, 0x2b, - 0xfd, 0xbc, 0xf3, 0x6a, 0x0a, 0x89, 0xd0, 0xd4, 0xb6, 0xbe, 0x03, 0x58, 0x55, 0x01, 0xfb, 0x10, - 0x5a, 0x92, 0x5d, 0x90, 0xf4, 0xb5, 0x03, 0x9a, 0xa0, 0xbd, 0x17, 0x16, 0x68, 0x15, 0xef, 0x38, - 0xe5, 0x8d, 0x78, 0xc7, 0x7e, 0x07, 0x77, 0x18, 0xc7, 0xd1, 0x25, 0x11, 0x4e, 0xa5, 0x59, 0x69, - 0xef, 0xf7, 0x3a, 0x7f, 0xe7, 0xde, 0xd1, 0x98, 0xca, 0xf3, 0xc9, 0x08, 0x45, 0x2c, 0x29, 0x9a, - 0x2d, 0x1e, 0x47, 0x22, 0xbe, 0xf0, 0xe5, 0x34, 0x23, 0x02, 0x75, 0xa3, 0xa8, 0x1b, 0xc7, 0x9c, - 0x08, 0x11, 0x2e, 0x19, 0x94, 0x08, 0x8e, 0x24, 0xbd, 0x22, 0x4e, 0xb5, 0x09, 0xda, 0xbb, 0x61, - 0x81, 0x5a, 0xb3, 0x32, 0xac, 0x07, 0x4c, 0x48, 0x12, 0x07, 0xaa, 0x1f, 0xfb, 0x25, 0xdc, 0x51, - 0xb6, 0x87, 0x34, 0x36, 0x2e, 0x7b, 0x30, 0x9f, 0x7b, 0x96, 0xf2, 0x7f, 0x32, 0x08, 0x2d, 0xf5, - 0xea, 0x24, 0xb6, 0xbf, 0xc0, 0x67, 0x86, 0x77, 0x88, 0x8d, 0x8e, 0x76, 0xbe, 0x95, 0xc1, 0x03, - 0x43, 0x54, 0x40, 0x7b, 0x00, 0x6b, 0x7a, 0xae, 0x4e, 0x45, 0x8b, 0x23, 0x35, 0xd1, 0xdf, 0x73, - 0xef, 0xd5, 0x03, 0x48, 0x07, 0x24, 0x0a, 0x4d, 0xb1, 0xfd, 0x16, 0x5a, 0xe4, 0x3a, 0xa3, 0x7c, - 0xaa, 0x9b, 0xad, 0x1f, 0x37, 0x90, 0xd9, 0x39, 0x5a, 0xee, 0x1c, 0x9d, 0x2e, 0x77, 0xde, 0xdb, - 0x55, 0x12, 0xb3, 0x3b, 0x0f, 0x84, 0x45, 0x4d, 0x6b, 0x0a, 0xf7, 0xfb, 0x13, 0xce, 0x49, 0x2a, - 0x1f, 0x31, 0x92, 0x95, 0xf1, 0xf2, 0x13, 0x8c, 0xb7, 0xbe, 0x95, 0x61, 0xbd, 0xd0, 0x3e, 0xfd, - 0xdc, 0x0d, 0x1e, 0x26, 0xfd, 0x1e, 0xee, 0xa5, 0x93, 0x84, 0x70, 0x2c, 0x19, 0xdf, 0x52, 0x7e, - 0x4d, 0x60, 0x07, 0xb0, 0x1e, 0x93, 0x94, 0x25, 0x34, 0xd5, 0x7c, 0xdb, 0xed, 0x61, 0x93, 0x62, - 0x3d, 0x9a, 0xea, 0x13, 0x46, 0xd3, 0xfb, 0x74, 0xff, 0xc7, 0x05, 0x3f, 0x72, 0x17, 0xdc, 0xe4, - 0x2e, 0xb8, 0xcd, 0x5d, 0x70, 0x9f, 0xbb, 0x60, 0xb6, 0x70, 0x4b, 0xb7, 0x0b, 0xb7, 0xf4, 0x6b, - 0xe1, 0x96, 0xbe, 0xfa, 0x1b, 0x84, 0x1b, 0x3f, 0xaa, 0x9f, 0xea, 0xb3, 0x7f, 0xed, 0xaf, 0xef, - 0x16, 0xcd, 0x3e, 0xb2, 0xf4, 0xe7, 0xf0, 0xe6, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x40, 0xf8, - 0x7e, 0xa1, 0x75, 0x04, 0x00, 0x00, -} - -func (this *Params) VerboseEqual(that interface{}) error { - if that == nil { - if this == nil { - return nil - } - return fmt.Errorf("that == nil && this != nil") - } - - that1, ok := that.(*Params) - if !ok { - that2, ok := that.(Params) - if ok { - that1 = &that2 - } else { - return fmt.Errorf("that is not of type *Params") - } - } - if that1 == nil { - if this == nil { - return nil - } - return fmt.Errorf("that is type *Params but is nil && this != nil") - } else if this == nil { - return fmt.Errorf("that is type *Params but is not nil && this == nil") - } - if len(this.Pairs) != len(that1.Pairs) { - return fmt.Errorf("Pairs this(%v) Not Equal that(%v)", len(this.Pairs), len(that1.Pairs)) - } - for i := range this.Pairs { - if !this.Pairs[i].Equal(&that1.Pairs[i]) { - return fmt.Errorf("Pairs this[%v](%v) Not Equal that[%v](%v)", i, this.Pairs[i], i, that1.Pairs[i]) - } - } - return nil + // 513 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x4f, 0x6b, 0xdb, 0x30, + 0x14, 0x8f, 0xd2, 0xd4, 0x4d, 0x94, 0x1e, 0x86, 0x33, 0x8a, 0x97, 0x81, 0x1d, 0x3c, 0x18, 0xb9, + 0xd4, 0xa2, 0xd9, 0x8e, 0x63, 0x90, 0x34, 0x97, 0xb2, 0x75, 0x33, 0xa6, 0x30, 0xd8, 0x25, 0x28, + 0xb6, 0x9a, 0x88, 0xc5, 0x96, 0x91, 0xe4, 0xd2, 0x7c, 0x8b, 0x1e, 0xf7, 0x11, 0xf6, 0x51, 0x7a, + 0x1a, 0x3d, 0x8e, 0x1d, 0xb2, 0xe1, 0x7c, 0x8b, 0x9d, 0x86, 0x24, 0xa7, 0xe9, 0xb1, 0x7f, 0x4e, + 0xf2, 0x7b, 0xef, 0xf7, 0x7e, 0xbf, 0xf7, 0xc7, 0x12, 0x3c, 0xc8, 0x39, 0x8d, 0xc9, 0x39, 0x21, + 0x09, 0xca, 0x31, 0xc7, 0xa9, 0x08, 0x72, 0xce, 0x24, 0xb3, 0x3b, 0x19, 0x9d, 0x52, 0x5e, 0x04, + 0xb7, 0xe1, 0xe0, 0xe2, 0xa8, 0xfb, 0x22, 0x66, 0x22, 0x65, 0x62, 0xa2, 0x21, 0xc8, 0x18, 0x06, + 0xdf, 0x7d, 0x3e, 0x63, 0x33, 0x66, 0xfc, 0xea, 0xab, 0xf2, 0x76, 0x62, 0x96, 0xa6, 0x2c, 0x43, + 0xe6, 0xa8, 0x9c, 0xde, 0x8c, 0xb1, 0xd9, 0x82, 0x20, 0x6d, 0x4d, 0x8b, 0x73, 0x24, 0x69, 0x4a, + 0x84, 0xc4, 0x69, 0x6e, 0x00, 0xfe, 0x7b, 0x68, 0x85, 0xba, 0x16, 0xfb, 0x2d, 0xdc, 0xcd, 0x31, + 0xe5, 0xc2, 0x01, 0xbd, 0x9d, 0x7e, 0x7b, 0xe0, 0x04, 0x55, 0x55, 0x15, 0xdf, 0x50, 0x08, 0x22, + 0x43, 0x4c, 0xf9, 0xa8, 0x71, 0xbd, 0xf2, 0x6a, 0x91, 0x01, 0xfb, 0x13, 0xf8, 0xec, 0x33, 0xc7, + 0xf1, 0x82, 0x88, 0x53, 0xcc, 0xc5, 0x1c, 0x2f, 0x08, 0xb7, 0x3f, 0xc0, 0x3d, 0x66, 0x7c, 0x9a, + 0x6b, 0x7f, 0x74, 0xf4, 0x6f, 0xe5, 0x1d, 0xce, 0xa8, 0x9c, 0x17, 0x53, 0x45, 0x57, 0x75, 0x53, + 0x1d, 0x87, 0x22, 0xf9, 0x86, 0xe4, 0x32, 0x27, 0x22, 0x18, 0xc6, 0xf1, 0x30, 0x49, 0x38, 0x11, + 0x22, 0xda, 0x30, 0xf8, 0x03, 0xd8, 0x19, 0xc6, 0x92, 0x5e, 0x10, 0xa5, 0xbd, 0xd5, 0x78, 0x09, + 0x5b, 0x54, 0x4c, 0xb0, 0x8e, 0x38, 0xa0, 0x07, 0xfa, 0xcd, 0xa8, 0x49, 0x85, 0x41, 0xfa, 0x3f, + 0x01, 0x6c, 0x87, 0x4c, 0x48, 0x92, 0x84, 0x6a, 0xa4, 0xf6, 0x2b, 0xb8, 0xa7, 0xaa, 0x9d, 0xd0, + 0x44, 0x43, 0x5b, 0x23, 0x58, 0xae, 0x3c, 0x4b, 0x11, 0x9e, 0x8c, 0x23, 0x4b, 0x85, 0x4e, 0x12, + 0xfb, 0x00, 0x5a, 0x46, 0xd3, 0xa9, 0x2b, 0x4c, 0x54, 0x59, 0xf6, 0x18, 0xee, 0xea, 0xc5, 0x38, + 0x3b, 0x3a, 0x35, 0x50, 0xdd, 0xff, 0x5e, 0x79, 0xaf, 0xef, 0xd1, 0xcf, 0x98, 0xc4, 0x91, 0x49, + 0xb6, 0xdf, 0x41, 0x8b, 0x5c, 0xe6, 0x94, 0x2f, 0x9d, 0x46, 0x0f, 0xf4, 0xdb, 0x83, 0x6e, 0x60, + 0x36, 0x13, 0x6c, 0x36, 0x13, 0x9c, 0x6d, 0x36, 0x33, 0x6a, 0x2a, 0x89, 0xab, 0x3f, 0x1e, 0x88, + 0xaa, 0x1c, 0x7f, 0x09, 0xf7, 0x8f, 0x0b, 0xce, 0x49, 0x26, 0x1f, 0xd0, 0xd0, 0x6d, 0xe1, 0xf5, + 0x27, 0x14, 0xee, 0x7f, 0xaf, 0xc3, 0x76, 0xa5, 0x7d, 0xf6, 0x65, 0x18, 0xde, 0x4f, 0xfa, 0x23, + 0x6c, 0x65, 0x45, 0x4a, 0x38, 0x96, 0x8c, 0x3f, 0x52, 0x7e, 0x4b, 0x60, 0x87, 0xb0, 0x9d, 0x90, + 0x8c, 0xa5, 0x34, 0xd3, 0x7c, 0x8f, 0xdb, 0xc3, 0x5d, 0x8a, 0xed, 0x68, 0x1a, 0x4f, 0x18, 0xcd, + 0xe8, 0xf4, 0x47, 0xe9, 0x82, 0xeb, 0xd2, 0x05, 0x37, 0xa5, 0x0b, 0xfe, 0x96, 0x2e, 0xb8, 0x5a, + 0xbb, 0xb5, 0x9b, 0xb5, 0x5b, 0xfb, 0xb5, 0x76, 0x6b, 0x5f, 0xd1, 0x1d, 0xb2, 0x4f, 0xfa, 0x2a, + 0x1d, 0xcf, 0x31, 0xcd, 0x90, 0xb9, 0x56, 0xe8, 0x12, 0x6d, 0x5f, 0x03, 0xcd, 0x3c, 0xb5, 0xf4, + 0xaf, 0xf0, 0xe6, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x99, 0xc4, 0x49, 0x26, 0x27, 0x04, 0x00, + 0x00, } + func (this *Params) Equal(that interface{}) bool { if that == nil { return this == nil @@ -412,58 +404,14 @@ func (this *Params) Equal(that interface{}) bool { } return true } -func (this *Pair) VerboseEqual(that interface{}) error { - if that == nil { - if this == nil { - return nil - } - return fmt.Errorf("that == nil && this != nil") - } - - that1, ok := that.(*Pair) - if !ok { - that2, ok := that.(Pair) - if ok { - that1 = &that2 - } else { - return fmt.Errorf("that is not of type *Pair") - } - } - if that1 == nil { - if this == nil { - return nil - } - return fmt.Errorf("that is type *Pair but is nil && this != nil") - } else if this == nil { - return fmt.Errorf("that is type *Pair but is not nil && this == nil") - } - if this.Token0 != that1.Token0 { - return fmt.Errorf("Token0 this(%v) Not Equal that(%v)", this.Token0, that1.Token0) - } - if this.Token1 != that1.Token1 { - return fmt.Errorf("Token1 this(%v) Not Equal that(%v)", this.Token1, that1.Token1) - } - if len(this.Oracles) != len(that1.Oracles) { - return fmt.Errorf("Oracles this(%v) Not Equal that(%v)", len(this.Oracles), len(that1.Oracles)) - } - for i := range this.Oracles { - if !bytes.Equal(this.Oracles[i], that1.Oracles[i]) { - return fmt.Errorf("Oracles this[%v](%v) Not Equal that[%v](%v)", i, this.Oracles[i], i, that1.Oracles[i]) - } - } - if this.Active != that1.Active { - return fmt.Errorf("Active this(%v) Not Equal that(%v)", this.Active, that1.Active) - } - return nil -} -func (this *Pair) Equal(that interface{}) bool { +func (this *OraclesMarshaler) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*Pair) + that1, ok := that.(*OraclesMarshaler) if !ok { - that2, ok := that.(Pair) + that2, ok := that.(OraclesMarshaler) if ok { that1 = &that2 } else { @@ -475,12 +423,6 @@ func (this *Pair) Equal(that interface{}) bool { } else if this == nil { return false } - if this.Token0 != that1.Token0 { - return false - } - if this.Token1 != that1.Token1 { - return false - } if len(this.Oracles) != len(that1.Oracles) { return false } @@ -489,49 +431,31 @@ func (this *Pair) Equal(that interface{}) bool { return false } } - if this.Active != that1.Active { - return false - } return true } -func (this *PostedPrice) VerboseEqual(that interface{}) error { +func (this *ActivePairMarshaler) Equal(that interface{}) bool { if that == nil { - if this == nil { - return nil - } - return fmt.Errorf("that == nil && this != nil") + return this == nil } - that1, ok := that.(*PostedPrice) + that1, ok := that.(*ActivePairMarshaler) if !ok { - that2, ok := that.(PostedPrice) + that2, ok := that.(ActivePairMarshaler) if ok { that1 = &that2 } else { - return fmt.Errorf("that is not of type *PostedPrice") + return false } } if that1 == nil { - if this == nil { - return nil - } - return fmt.Errorf("that is type *PostedPrice but is nil && this != nil") + return this == nil } else if this == nil { - return fmt.Errorf("that is type *PostedPrice but is not nil && this == nil") - } - if this.PairID != that1.PairID { - return fmt.Errorf("PairID this(%v) Not Equal that(%v)", this.PairID, that1.PairID) - } - if !bytes.Equal(this.OracleAddress, that1.OracleAddress) { - return fmt.Errorf("OracleAddress this(%v) Not Equal that(%v)", this.OracleAddress, that1.OracleAddress) - } - if !this.Price.Equal(that1.Price) { - return fmt.Errorf("Price this(%v) Not Equal that(%v)", this.Price, that1.Price) + return false } - if !this.Expiry.Equal(that1.Expiry) { - return fmt.Errorf("Expiry this(%v) Not Equal that(%v)", this.Expiry, that1.Expiry) + if this.IsActive != that1.IsActive { + return false } - return nil + return true } func (this *PostedPrice) Equal(that interface{}) bool { if that == nil { @@ -555,7 +479,7 @@ func (this *PostedPrice) Equal(that interface{}) bool { if this.PairID != that1.PairID { return false } - if !bytes.Equal(this.OracleAddress, that1.OracleAddress) { + if this.Oracle != that1.Oracle { return false } if !this.Price.Equal(that1.Price) { @@ -566,39 +490,6 @@ func (this *PostedPrice) Equal(that interface{}) bool { } return true } -func (this *CurrentPrice) VerboseEqual(that interface{}) error { - if that == nil { - if this == nil { - return nil - } - return fmt.Errorf("that == nil && this != nil") - } - - that1, ok := that.(*CurrentPrice) - if !ok { - that2, ok := that.(CurrentPrice) - if ok { - that1 = &that2 - } else { - return fmt.Errorf("that is not of type *CurrentPrice") - } - } - if that1 == nil { - if this == nil { - return nil - } - return fmt.Errorf("that is type *CurrentPrice but is nil && this != nil") - } else if this == nil { - return fmt.Errorf("that is type *CurrentPrice but is not nil && this == nil") - } - if this.PairID != that1.PairID { - return fmt.Errorf("PairID this(%v) Not Equal that(%v)", this.PairID, that1.PairID) - } - if !this.Price.Equal(that1.Price) { - return fmt.Errorf("Price this(%v) Not Equal that(%v)", this.Price, that1.Price) - } - return nil -} func (this *CurrentPrice) Equal(that interface{}) bool { if that == nil { return this == nil @@ -626,45 +517,6 @@ func (this *CurrentPrice) Equal(that interface{}) bool { } return true } -func (this *CurrentTWAP) VerboseEqual(that interface{}) error { - if that == nil { - if this == nil { - return nil - } - return fmt.Errorf("that == nil && this != nil") - } - - that1, ok := that.(*CurrentTWAP) - if !ok { - that2, ok := that.(CurrentTWAP) - if ok { - that1 = &that2 - } else { - return fmt.Errorf("that is not of type *CurrentTWAP") - } - } - if that1 == nil { - if this == nil { - return nil - } - return fmt.Errorf("that is type *CurrentTWAP but is nil && this != nil") - } else if this == nil { - return fmt.Errorf("that is type *CurrentTWAP but is not nil && this == nil") - } - if this.PairID != that1.PairID { - return fmt.Errorf("PairID this(%v) Not Equal that(%v)", this.PairID, that1.PairID) - } - if !this.Numerator.Equal(that1.Numerator) { - return fmt.Errorf("Numerator this(%v) Not Equal that(%v)", this.Numerator, that1.Numerator) - } - if !this.Denominator.Equal(that1.Denominator) { - return fmt.Errorf("Denominator this(%v) Not Equal that(%v)", this.Denominator, that1.Denominator) - } - if !this.Price.Equal(that1.Price) { - return fmt.Errorf("Price this(%v) Not Equal that(%v)", this.Price, that1.Price) - } - return nil -} func (this *CurrentTWAP) Equal(that interface{}) bool { if that == nil { return this == nil @@ -735,7 +587,7 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Pair) Marshal() (dAtA []byte, err error) { +func (m *OraclesMarshaler) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -745,48 +597,57 @@ func (m *Pair) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Pair) MarshalTo(dAtA []byte) (int, error) { +func (m *OraclesMarshaler) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Pair) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *OraclesMarshaler) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Active { - i-- - if m.Active { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x20 - } if len(m.Oracles) > 0 { for iNdEx := len(m.Oracles) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Oracles[iNdEx]) copy(dAtA[i:], m.Oracles[iNdEx]) i = encodeVarintParams(dAtA, i, uint64(len(m.Oracles[iNdEx]))) i-- - dAtA[i] = 0x1a + dAtA[i] = 0xa } } - if len(m.Token1) > 0 { - i -= len(m.Token1) - copy(dAtA[i:], m.Token1) - i = encodeVarintParams(dAtA, i, uint64(len(m.Token1))) - i-- - dAtA[i] = 0x12 + return len(dAtA) - i, nil +} + +func (m *ActivePairMarshaler) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - if len(m.Token0) > 0 { - i -= len(m.Token0) - copy(dAtA[i:], m.Token0) - i = encodeVarintParams(dAtA, i, uint64(len(m.Token0))) + return dAtA[:n], nil +} + +func (m *ActivePairMarshaler) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ActivePairMarshaler) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.IsActive { i-- - dAtA[i] = 0xa + if m.IsActive { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } @@ -829,10 +690,10 @@ func (m *PostedPrice) MarshalToSizedBuffer(dAtA []byte) (int, error) { } i-- dAtA[i] = 0x1a - if len(m.OracleAddress) > 0 { - i -= len(m.OracleAddress) - copy(dAtA[i:], m.OracleAddress) - i = encodeVarintParams(dAtA, i, uint64(len(m.OracleAddress))) + if len(m.Oracle) > 0 { + i -= len(m.Oracle) + copy(dAtA[i:], m.Oracle) + i = encodeVarintParams(dAtA, i, uint64(len(m.Oracle))) i-- dAtA[i] = 0x12 } @@ -972,27 +833,28 @@ func (m *Params) Size() (n int) { return n } -func (m *Pair) Size() (n int) { +func (m *OraclesMarshaler) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Token0) - if l > 0 { - n += 1 + l + sovParams(uint64(l)) - } - l = len(m.Token1) - if l > 0 { - n += 1 + l + sovParams(uint64(l)) - } if len(m.Oracles) > 0 { for _, b := range m.Oracles { l = len(b) n += 1 + l + sovParams(uint64(l)) } } - if m.Active { + return n +} + +func (m *ActivePairMarshaler) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.IsActive { n += 2 } return n @@ -1008,7 +870,7 @@ func (m *PostedPrice) Size() (n int) { if l > 0 { n += 1 + l + sovParams(uint64(l)) } - l = len(m.OracleAddress) + l = len(m.Oracle) if l > 0 { n += 1 + l + sovParams(uint64(l)) } @@ -1117,7 +979,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Pairs = append(m.Pairs, Pair{}) + m.Pairs = append(m.Pairs, common.AssetPair{}) if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } @@ -1143,7 +1005,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { } return nil } -func (m *Pair) Unmarshal(dAtA []byte) error { +func (m *OraclesMarshaler) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1166,17 +1028,17 @@ func (m *Pair) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Pair: wiretype end group for non-group") + return fmt.Errorf("proto: OraclesMarshaler: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Pair: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: OraclesMarshaler: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Token0", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Oracles", wireType) } - var stringLen uint64 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowParams @@ -1186,91 +1048,77 @@ func (m *Pair) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if byteLen < 0 { return ErrInvalidLengthParams } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthParams } if postIndex > l { return io.ErrUnexpectedEOF } - m.Token0 = string(dAtA[iNdEx:postIndex]) + m.Oracles = append(m.Oracles, make([]byte, postIndex-iNdEx)) + copy(m.Oracles[len(m.Oracles)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Token1", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowParams - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthParams + default: + iNdEx = preIndex + skippy, err := skipParams(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + intStringLen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthParams } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.Token1 = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Oracles", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowParams - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthParams - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthParams + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ActivePairMarshaler) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - m.Oracles = append(m.Oracles, make([]byte, postIndex-iNdEx)) - copy(m.Oracles[len(m.Oracles)-1], dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ActivePairMarshaler: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ActivePairMarshaler: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Active", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IsActive", wireType) } var v int for shift := uint(0); ; shift += 7 { @@ -1287,7 +1135,7 @@ func (m *Pair) Unmarshal(dAtA []byte) error { break } } - m.Active = bool(v != 0) + m.IsActive = bool(v != 0) default: iNdEx = preIndex skippy, err := skipParams(dAtA[iNdEx:]) @@ -1372,9 +1220,9 @@ func (m *PostedPrice) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field OracleAddress", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Oracle", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowParams @@ -1384,25 +1232,23 @@ func (m *PostedPrice) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthParams } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthParams } if postIndex > l { return io.ErrUnexpectedEOF } - m.OracleAddress = append(m.OracleAddress[:0], dAtA[iNdEx:postIndex]...) - if m.OracleAddress == nil { - m.OracleAddress = []byte{} - } + m.Oracle = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { diff --git a/x/pricefeed/types/query.pb.go b/x/pricefeed/types/query.pb.go index c9efc534f..f9c283c9a 100644 --- a/x/pricefeed/types/query.pb.go +++ b/x/pricefeed/types/query.pb.go @@ -679,82 +679,82 @@ func (m *PairResponse) GetActive() bool { } func init() { - proto.RegisterType((*QueryParamsRequest)(nil), "NibiruChain.pricefeed.v1.QueryParamsRequest") - proto.RegisterType((*QueryParamsResponse)(nil), "NibiruChain.pricefeed.v1.QueryParamsResponse") - proto.RegisterType((*QueryPriceRequest)(nil), "NibiruChain.pricefeed.v1.QueryPriceRequest") - proto.RegisterType((*QueryPriceResponse)(nil), "NibiruChain.pricefeed.v1.QueryPriceResponse") - proto.RegisterType((*QueryPricesRequest)(nil), "NibiruChain.pricefeed.v1.QueryPricesRequest") - proto.RegisterType((*QueryPricesResponse)(nil), "NibiruChain.pricefeed.v1.QueryPricesResponse") - proto.RegisterType((*QueryRawPricesRequest)(nil), "NibiruChain.pricefeed.v1.QueryRawPricesRequest") - proto.RegisterType((*QueryRawPricesResponse)(nil), "NibiruChain.pricefeed.v1.QueryRawPricesResponse") - proto.RegisterType((*QueryOraclesRequest)(nil), "NibiruChain.pricefeed.v1.QueryOraclesRequest") - proto.RegisterType((*QueryOraclesResponse)(nil), "NibiruChain.pricefeed.v1.QueryOraclesResponse") - proto.RegisterType((*QueryPairsRequest)(nil), "NibiruChain.pricefeed.v1.QueryPairsRequest") - proto.RegisterType((*QueryPairsResponse)(nil), "NibiruChain.pricefeed.v1.QueryPairsResponse") - proto.RegisterType((*PostedPriceResponse)(nil), "NibiruChain.pricefeed.v1.PostedPriceResponse") - proto.RegisterType((*CurrentPriceResponse)(nil), "NibiruChain.pricefeed.v1.CurrentPriceResponse") - proto.RegisterType((*PairResponse)(nil), "NibiruChain.pricefeed.v1.PairResponse") + proto.RegisterType((*QueryParamsRequest)(nil), "nibiru.pricefeed.v1.QueryParamsRequest") + proto.RegisterType((*QueryParamsResponse)(nil), "nibiru.pricefeed.v1.QueryParamsResponse") + proto.RegisterType((*QueryPriceRequest)(nil), "nibiru.pricefeed.v1.QueryPriceRequest") + proto.RegisterType((*QueryPriceResponse)(nil), "nibiru.pricefeed.v1.QueryPriceResponse") + proto.RegisterType((*QueryPricesRequest)(nil), "nibiru.pricefeed.v1.QueryPricesRequest") + proto.RegisterType((*QueryPricesResponse)(nil), "nibiru.pricefeed.v1.QueryPricesResponse") + proto.RegisterType((*QueryRawPricesRequest)(nil), "nibiru.pricefeed.v1.QueryRawPricesRequest") + proto.RegisterType((*QueryRawPricesResponse)(nil), "nibiru.pricefeed.v1.QueryRawPricesResponse") + proto.RegisterType((*QueryOraclesRequest)(nil), "nibiru.pricefeed.v1.QueryOraclesRequest") + proto.RegisterType((*QueryOraclesResponse)(nil), "nibiru.pricefeed.v1.QueryOraclesResponse") + proto.RegisterType((*QueryPairsRequest)(nil), "nibiru.pricefeed.v1.QueryPairsRequest") + proto.RegisterType((*QueryPairsResponse)(nil), "nibiru.pricefeed.v1.QueryPairsResponse") + proto.RegisterType((*PostedPriceResponse)(nil), "nibiru.pricefeed.v1.PostedPriceResponse") + proto.RegisterType((*CurrentPriceResponse)(nil), "nibiru.pricefeed.v1.CurrentPriceResponse") + proto.RegisterType((*PairResponse)(nil), "nibiru.pricefeed.v1.PairResponse") } func init() { proto.RegisterFile("pricefeed/query.proto", fileDescriptor_d96dcacfb6f84073) } var fileDescriptor_d96dcacfb6f84073 = []byte{ // 869 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xcf, 0x6f, 0x1b, 0x45, - 0x14, 0xf6, 0xa4, 0xfe, 0x51, 0x0f, 0x14, 0x89, 0x89, 0x1d, 0x2c, 0xab, 0xec, 0x9a, 0x45, 0x94, - 0x88, 0xc6, 0xbb, 0xb5, 0x0b, 0x3d, 0x20, 0x84, 0x84, 0x9b, 0x4b, 0x39, 0x00, 0x5d, 0x38, 0xc1, - 0x21, 0x1a, 0xdb, 0x13, 0x77, 0x68, 0xbd, 0xb3, 0x9d, 0x59, 0x27, 0x8d, 0x10, 0x07, 0x7a, 0x42, - 0x70, 0xa0, 0x12, 0x82, 0x03, 0x12, 0x12, 0x17, 0x24, 0xc4, 0x5f, 0xd2, 0x63, 0x25, 0x2e, 0x88, - 0x43, 0x5a, 0x1c, 0xf8, 0x3f, 0xd0, 0xce, 0xbc, 0xdd, 0xee, 0x26, 0xfe, 0xb1, 0xa2, 0xa7, 0x64, - 0xdf, 0xbc, 0xef, 0xbd, 0xef, 0x7d, 0xf3, 0xe6, 0x33, 0x6e, 0x86, 0x92, 0x8f, 0xd8, 0x3e, 0x63, - 0x63, 0xef, 0xee, 0x8c, 0xc9, 0x23, 0x37, 0x94, 0x22, 0x12, 0xa4, 0xf5, 0x01, 0x1f, 0x72, 0x39, - 0xbb, 0x7e, 0x8b, 0xf2, 0xc0, 0x4d, 0x53, 0xdc, 0x83, 0x5e, 0xbb, 0x31, 0x11, 0x13, 0xa1, 0x93, - 0xbc, 0xf8, 0x3f, 0x93, 0xdf, 0xbe, 0x38, 0x11, 0x62, 0x72, 0x87, 0x79, 0x34, 0xe4, 0x1e, 0x0d, - 0x02, 0x11, 0xd1, 0x88, 0x8b, 0x40, 0xc1, 0xa9, 0x0d, 0xa7, 0xfa, 0x6b, 0x38, 0xdb, 0xf7, 0x22, - 0x3e, 0x65, 0x2a, 0xa2, 0xd3, 0x10, 0x12, 0xb6, 0x9e, 0xb2, 0x08, 0xa9, 0xa4, 0x53, 0x00, 0x3a, - 0x0d, 0x4c, 0x6e, 0xc6, 0xac, 0x3e, 0xd2, 0x41, 0x9f, 0xdd, 0x9d, 0x31, 0x15, 0x39, 0x9f, 0xe1, - 0xcd, 0x5c, 0x54, 0x85, 0x22, 0x50, 0x8c, 0xbc, 0x8b, 0xab, 0x06, 0xdc, 0x42, 0x1d, 0xb4, 0xfd, - 0x5c, 0xbf, 0xe3, 0x2e, 0x1b, 0xc2, 0x35, 0xc8, 0x41, 0xf9, 0xe1, 0xb1, 0x5d, 0xf2, 0x01, 0xf5, - 0x76, 0xf9, 0xeb, 0x5f, 0xec, 0x92, 0xd3, 0xc7, 0x2f, 0x9a, 0xe2, 0x71, 0x3e, 0x74, 0x24, 0x2f, - 0xe1, 0x5a, 0x48, 0xb9, 0xdc, 0xe3, 0x63, 0x5d, 0xbb, 0x1e, 0x63, 0xb8, 0xbc, 0x31, 0x06, 0xcc, - 0x7e, 0x42, 0xd3, 0x60, 0x80, 0xcf, 0xfb, 0xb8, 0xa2, 0x9b, 0x02, 0x1d, 0x77, 0x39, 0x9d, 0xeb, - 0x33, 0x29, 0x59, 0x10, 0xe5, 0xe0, 0x40, 0xce, 0x94, 0x80, 0x3e, 0x8d, 0x6c, 0x9f, 0x54, 0x8e, - 0xfb, 0x28, 0xd1, 0x03, 0xc2, 0xd0, 0x9f, 0xe1, 0xaa, 0x06, 0xc7, 0x7a, 0x9c, 0xfb, 0x1f, 0x04, - 0x5e, 0x8e, 0x09, 0xfc, 0xfe, 0xd8, 0x6e, 0x2e, 0x3a, 0x55, 0x3e, 0x14, 0x07, 0x6a, 0xd7, 0x70, - 0x53, 0x73, 0xf0, 0xe9, 0x61, 0x8e, 0xdd, 0x3a, 0xe9, 0xbe, 0x41, 0x78, 0xeb, 0x34, 0x10, 0xf8, - 0x7f, 0x8e, 0xb1, 0xa4, 0x87, 0x7b, 0xb9, 0x19, 0xba, 0x2b, 0xee, 0x54, 0xa8, 0x88, 0x8d, 0xf3, - 0x23, 0x5c, 0x84, 0x11, 0x1a, 0x0b, 0x0e, 0x95, 0x5f, 0x97, 0x49, 0x4f, 0x20, 0xf3, 0x26, 0x08, - 0xf9, 0xa1, 0xa4, 0xa3, 0x3b, 0x85, 0x47, 0xb8, 0x86, 0x1b, 0x79, 0x14, 0xf0, 0x6f, 0xe1, 0x9a, - 0x30, 0x21, 0x4d, 0xbe, 0xee, 0x27, 0x9f, 0x80, 0xdb, 0x4c, 0x36, 0x8d, 0x72, 0x99, 0x5e, 0xa6, - 0x48, 0x37, 0x5e, 0x07, 0xa1, 0xd4, 0xc7, 0xb8, 0x12, 0xb7, 0x4c, 0x54, 0xb8, 0xb4, 0x6a, 0xb3, - 0xb9, 0x4c, 0xc7, 0x6f, 0xc2, 0xf8, 0x17, 0xb2, 0x51, 0xe5, 0x9b, 0x5a, 0xc0, 0xe2, 0x5f, 0x84, - 0x37, 0x17, 0xa8, 0x43, 0x5e, 0x3d, 0x35, 0xf4, 0x00, 0xcf, 0x8f, 0xed, 0x6a, 0x5c, 0xe8, 0xc6, - 0x6e, 0x22, 0x00, 0x79, 0x0d, 0xbf, 0x60, 0x66, 0xda, 0xa3, 0xe3, 0xb1, 0x64, 0x4a, 0xb5, 0x36, - 0xb4, 0x40, 0x17, 0x4c, 0xf4, 0x3d, 0x13, 0x24, 0xbb, 0xc9, 0x4b, 0x38, 0xa7, 0x2b, 0xb9, 0x31, - 0xad, 0xbf, 0x8e, 0xed, 0x4b, 0x13, 0x1e, 0xdd, 0x9a, 0x0d, 0xdd, 0x91, 0x98, 0x7a, 0x23, 0xa1, - 0xa6, 0x42, 0xc1, 0x9f, 0xae, 0x1a, 0xdf, 0xf6, 0xa2, 0xa3, 0x90, 0x29, 0x77, 0x97, 0x8d, 0xe0, - 0x0d, 0x90, 0x77, 0x70, 0x95, 0xdd, 0x0b, 0xb9, 0x3c, 0x6a, 0x95, 0xf5, 0x83, 0x6a, 0xbb, 0xc6, - 0x56, 0xdc, 0xc4, 0x56, 0xdc, 0x4f, 0x12, 0x5b, 0x19, 0x9c, 0x8f, 0x5b, 0x3c, 0x78, 0x6c, 0x23, - 0x1f, 0x30, 0xce, 0x57, 0x08, 0x37, 0x16, 0x2d, 0x72, 0xb1, 0x41, 0xd3, 0x09, 0x36, 0x9e, 0x61, - 0x02, 0xe7, 0x07, 0x84, 0x9f, 0xcf, 0x5e, 0x45, 0xb1, 0xde, 0x5b, 0xb8, 0x1a, 0x89, 0xdb, 0x2c, - 0xb8, 0x02, 0xe2, 0xc2, 0x57, 0x1a, 0xef, 0x19, 0x59, 0x21, 0xde, 0xcb, 0xee, 0x5d, 0x39, 0xb7, - 0x77, 0x31, 0x82, 0x8e, 0x22, 0x7e, 0xc0, 0x5a, 0x95, 0x0e, 0xda, 0x3e, 0xef, 0xc3, 0x57, 0xff, - 0xa7, 0x1a, 0xae, 0xe8, 0xad, 0x23, 0xdf, 0x21, 0x5c, 0x35, 0xe6, 0x48, 0x76, 0x96, 0x2f, 0xd9, - 0x59, 0x4f, 0x6e, 0x77, 0x0b, 0x66, 0x9b, 0xc1, 0x9d, 0xed, 0xfb, 0x7f, 0xfc, 0xf3, 0xfd, 0x86, - 0x43, 0x3a, 0x5e, 0xa0, 0x61, 0xde, 0xd3, 0x1f, 0x80, 0x83, 0xde, 0x90, 0x45, 0xb4, 0x07, 0x3f, - 0x04, 0xe4, 0x47, 0x84, 0x2b, 0xfa, 0xc2, 0xc8, 0xe5, 0x75, 0x2d, 0x32, 0x8e, 0xdd, 0xde, 0x29, - 0x96, 0x0c, 0x74, 0xfa, 0x9a, 0xce, 0x0e, 0x79, 0x63, 0x05, 0x1d, 0x6d, 0x14, 0xde, 0x17, 0x70, - 0x5f, 0x5f, 0x1a, 0xa9, 0x74, 0x90, 0x14, 0x6a, 0x56, 0x5c, 0xaa, 0x9c, 0x0d, 0x16, 0x92, 0xca, - 0xd0, 0xf8, 0x15, 0xe1, 0x7a, 0x6a, 0xa3, 0xc4, 0x5b, 0xd3, 0xe6, 0xb4, 0x53, 0xb7, 0xaf, 0x14, - 0x07, 0x00, 0xb5, 0xb7, 0x34, 0x35, 0x8f, 0x74, 0x97, 0x53, 0x93, 0xf4, 0xf0, 0x8c, 0x72, 0x3f, - 0x23, 0x5c, 0x03, 0xb3, 0x24, 0xeb, 0xc4, 0xc8, 0x5b, 0x71, 0xdb, 0x2d, 0x9a, 0x0e, 0x0c, 0xaf, - 0x6a, 0x86, 0x5d, 0x72, 0x79, 0x39, 0x43, 0x78, 0x1c, 0x19, 0x7e, 0xdf, 0xc6, 0x2b, 0x17, 0x5b, - 0xe4, 0xfa, 0x95, 0xcb, 0x58, 0xf7, 0xfa, 0x95, 0xcb, 0x5a, 0xba, 0xf3, 0xba, 0x66, 0xf6, 0x0a, - 0xb1, 0x57, 0xbd, 0x00, 0x2e, 0xd5, 0xe0, 0xe6, 0x93, 0xbf, 0x2d, 0xf4, 0xdb, 0xdc, 0x42, 0x0f, - 0xe7, 0x16, 0x7a, 0x34, 0xb7, 0xd0, 0x93, 0xb9, 0x85, 0x1e, 0x9c, 0x58, 0xa5, 0x47, 0x27, 0x56, - 0xe9, 0xcf, 0x13, 0xab, 0xf4, 0xa9, 0x97, 0x71, 0xa1, 0x0c, 0x85, 0xa4, 0xf0, 0xbd, 0x4c, 0x69, - 0x6d, 0x49, 0xc3, 0xaa, 0x76, 0xcc, 0xab, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xcb, 0x77, 0xa2, - 0xfa, 0xfd, 0x09, 0x00, 0x00, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0xcf, 0x6f, 0x1b, 0x45, + 0x14, 0xc7, 0x3d, 0xa9, 0xed, 0x36, 0xd3, 0x1f, 0x12, 0x63, 0x3b, 0x58, 0xa6, 0xec, 0xa6, 0x8b, + 0x68, 0xdc, 0x96, 0xec, 0x62, 0x17, 0x2a, 0x81, 0xb8, 0xe0, 0x86, 0x43, 0x2f, 0x85, 0xae, 0x10, + 0x07, 0x2e, 0x61, 0x6c, 0x4f, 0xdd, 0xa1, 0xf5, 0xee, 0x66, 0x66, 0x9d, 0x1f, 0x42, 0x39, 0x80, + 0x04, 0x42, 0x9c, 0x82, 0x10, 0x12, 0xc7, 0x1c, 0x11, 0x7f, 0x49, 0x8e, 0x91, 0xb8, 0x20, 0x0e, + 0x49, 0x70, 0xe0, 0xbf, 0xe0, 0x80, 0x76, 0xe6, 0xed, 0x66, 0x37, 0x59, 0xff, 0x40, 0x3d, 0x25, + 0xfb, 0x66, 0xde, 0xfb, 0x7e, 0xde, 0x9b, 0xe7, 0x2f, 0xae, 0x05, 0x82, 0xf7, 0xd8, 0x53, 0xc6, + 0xfa, 0xce, 0xc6, 0x88, 0x89, 0x1d, 0x3b, 0x10, 0x7e, 0xe8, 0x93, 0x8a, 0xc7, 0xbb, 0x5c, 0x8c, + 0xec, 0xe4, 0xd4, 0xde, 0x6c, 0x35, 0xaa, 0x03, 0x7f, 0xe0, 0xab, 0x73, 0x27, 0xfa, 0x4f, 0x5f, + 0x6d, 0xdc, 0x1c, 0xf8, 0xfe, 0xe0, 0x05, 0x73, 0x68, 0xc0, 0x1d, 0xea, 0x79, 0x7e, 0x48, 0x43, + 0xee, 0x7b, 0x12, 0x4e, 0x4d, 0x38, 0x55, 0x5f, 0xdd, 0xd1, 0x53, 0x27, 0xe4, 0x43, 0x26, 0x43, + 0x3a, 0x0c, 0xe0, 0xc2, 0xd2, 0x19, 0x40, 0x40, 0x05, 0x1d, 0x42, 0xa2, 0x55, 0xc5, 0xe4, 0x49, + 0x04, 0xf4, 0x89, 0x0a, 0xba, 0x6c, 0x63, 0xc4, 0x64, 0x68, 0x7d, 0x86, 0x2b, 0x99, 0xa8, 0x0c, + 0x7c, 0x4f, 0x32, 0xf2, 0x1e, 0x2e, 0xeb, 0xe4, 0x3a, 0x5a, 0x46, 0xcd, 0xab, 0xed, 0xd7, 0xec, + 0x1c, 0x7e, 0x5b, 0x27, 0x75, 0x8a, 0x07, 0x47, 0x66, 0xc1, 0x85, 0x84, 0xf7, 0x8b, 0xdf, 0xef, + 0x9b, 0x05, 0xab, 0x8d, 0x5f, 0xd1, 0x75, 0xa3, 0xfb, 0x20, 0x46, 0x5e, 0xc5, 0x97, 0x03, 0xca, + 0xc5, 0x3a, 0xef, 0xab, 0xb2, 0x8b, 0x51, 0x0e, 0x17, 0x8f, 0xfa, 0x90, 0x43, 0x63, 0x42, 0x9d, + 0x03, 0x28, 0x1f, 0xe1, 0x92, 0x12, 0x05, 0x92, 0x3b, 0xb9, 0x24, 0x0f, 0x47, 0x42, 0x30, 0x2f, + 0xcc, 0x64, 0x02, 0x97, 0xce, 0x06, 0x89, 0x6a, 0x5a, 0x22, 0x19, 0xc2, 0x6e, 0x3c, 0x04, 0x88, + 0x82, 0xf2, 0x17, 0xb8, 0xac, 0x72, 0xa3, 0x21, 0x5c, 0xfa, 0x7f, 0xd2, 0xaf, 0x47, 0xd2, 0xbf, + 0x1d, 0x9b, 0xb5, 0xbc, 0x53, 0xe9, 0x42, 0x5d, 0x80, 0x7a, 0x80, 0x6b, 0x4a, 0xde, 0xa5, 0x5b, + 0x19, 0xae, 0x59, 0xf3, 0xfa, 0x16, 0xe1, 0xa5, 0xf3, 0x89, 0x80, 0xce, 0x30, 0x16, 0x74, 0x6b, + 0x3d, 0x83, 0xdf, 0xcc, 0x7f, 0x43, 0x5f, 0x86, 0xac, 0x9f, 0xa5, 0xbf, 0x09, 0xf4, 0xd5, 0x9c, + 0x43, 0xe9, 0x2e, 0x8a, 0x58, 0x0e, 0x38, 0xde, 0x81, 0xf1, 0x7d, 0x2c, 0x68, 0xef, 0xc5, 0xdc, + 0xf4, 0x0f, 0x70, 0x35, 0x9b, 0x05, 0xe8, 0x75, 0x7c, 0xd9, 0xd7, 0x21, 0xc5, 0xbd, 0xe8, 0xc6, + 0x9f, 0x90, 0x57, 0x89, 0x37, 0x8b, 0x72, 0x91, 0xbc, 0xe0, 0x97, 0xc9, 0x72, 0xab, 0x20, 0x94, + 0x7a, 0x8c, 0x4b, 0x91, 0x64, 0x3c, 0x80, 0x5b, 0x13, 0x96, 0x98, 0x8b, 0xa4, 0xf3, 0x1a, 0x74, + 0x7e, 0x3d, 0x1d, 0x95, 0xae, 0x2e, 0x03, 0x00, 0xff, 0x20, 0x5c, 0xc9, 0x19, 0x0c, 0x79, 0xe3, + 0x5c, 0xbf, 0x1d, 0x3c, 0x3e, 0x32, 0xcb, 0x51, 0xa1, 0x47, 0x6b, 0x71, 0xef, 0xe4, 0x4d, 0x7c, + 0x43, 0xb7, 0xb3, 0x4e, 0xfb, 0x7d, 0xc1, 0xa4, 0xac, 0x2f, 0xa8, 0xd9, 0x5c, 0xd7, 0xd1, 0x0f, + 0x75, 0x90, 0xac, 0xc5, 0x4b, 0x7f, 0x49, 0x55, 0xb2, 0x23, 0xac, 0x3f, 0x8f, 0xcc, 0xdb, 0x03, + 0x1e, 0x3e, 0x1b, 0x75, 0xed, 0x9e, 0x3f, 0x74, 0x7a, 0xbe, 0x1c, 0xfa, 0x12, 0xfe, 0xac, 0xca, + 0xfe, 0x73, 0x27, 0xdc, 0x09, 0x98, 0xb4, 0xd7, 0x58, 0x0f, 0x76, 0x9e, 0x7c, 0x80, 0xcb, 0x6c, + 0x3b, 0xe0, 0x62, 0xa7, 0x5e, 0x54, 0xbf, 0x9d, 0x86, 0xad, 0xcd, 0xc3, 0x8e, 0xcd, 0xc3, 0xfe, + 0x34, 0x36, 0x8f, 0xce, 0x95, 0x48, 0x62, 0xef, 0xd8, 0x44, 0x2e, 0xe4, 0x58, 0x5f, 0x23, 0x5c, + 0xcd, 0x5b, 0xdf, 0xf9, 0x1a, 0x4d, 0x3a, 0x58, 0x78, 0x89, 0x0e, 0xac, 0x9f, 0x11, 0xbe, 0x96, + 0x7e, 0x8a, 0xf9, 0xb4, 0x97, 0x70, 0x39, 0xf4, 0x9f, 0x33, 0xef, 0x6d, 0x18, 0x2e, 0x7c, 0x25, + 0xf1, 0x96, 0x1e, 0x2b, 0xc4, 0x5b, 0xe9, 0x95, 0x2b, 0x66, 0x56, 0x2e, 0xca, 0xa0, 0xbd, 0x90, + 0x6f, 0xb2, 0x7a, 0x69, 0x19, 0x35, 0xaf, 0xb8, 0xf0, 0xd5, 0xfe, 0xb7, 0x8c, 0x4b, 0x6a, 0xe1, + 0xc8, 0x0f, 0x08, 0x5f, 0x4d, 0x39, 0x28, 0x59, 0xc9, 0x5d, 0xb2, 0x8b, 0xce, 0xdb, 0x68, 0xce, + 0xbe, 0xa8, 0x7b, 0xb6, 0x9a, 0xdf, 0xfc, 0xfe, 0xf7, 0x4f, 0x0b, 0x16, 0x59, 0x76, 0x74, 0x86, + 0x73, 0xe6, 0xf0, 0x9b, 0xad, 0x2e, 0x0b, 0x69, 0x0b, 0x9c, 0x9e, 0xfc, 0x88, 0x30, 0x3e, 0x73, + 0x32, 0x72, 0x7b, 0x8a, 0x44, 0xca, 0x97, 0x1b, 0x2b, 0x33, 0xef, 0x01, 0x49, 0x5b, 0x91, 0xbc, + 0x45, 0xee, 0x4e, 0x21, 0x51, 0xce, 0xe0, 0x7c, 0x05, 0xaf, 0xb4, 0x9b, 0x1a, 0x90, 0x3a, 0x21, + 0xb3, 0xc4, 0xe6, 0x1a, 0x50, 0xc6, 0xed, 0xe6, 0x1a, 0x90, 0x16, 0xdf, 0x47, 0xf8, 0x46, 0xd6, + 0x32, 0xc9, 0xdd, 0xc9, 0x32, 0xe7, 0x0d, 0xb9, 0x71, 0x6f, 0xae, 0xbb, 0x40, 0xf5, 0xae, 0xa2, + 0x72, 0xc8, 0xea, 0x64, 0x2a, 0x41, 0xb7, 0x2e, 0xcc, 0xeb, 0x17, 0x84, 0xaf, 0xa5, 0x8d, 0x91, + 0x4c, 0x99, 0x43, 0xd6, 0x71, 0x1b, 0x77, 0xe6, 0xb8, 0x09, 0x70, 0xf7, 0x15, 0xdc, 0x2a, 0xb9, + 0x37, 0x19, 0x0e, 0x7e, 0x03, 0x29, 0xb4, 0xef, 0x92, 0xf5, 0x8a, 0xec, 0x70, 0xea, 0x7a, 0xa5, + 0xcc, 0x79, 0xea, 0x7a, 0xa5, 0xfd, 0xda, 0x5a, 0x51, 0x50, 0xb7, 0x88, 0x39, 0x6d, 0xd1, 0xb9, + 0x90, 0x9d, 0x27, 0x27, 0x7f, 0x19, 0xe8, 0xd7, 0xb1, 0x81, 0x0e, 0xc6, 0x06, 0x3a, 0x1c, 0x1b, + 0xe8, 0x64, 0x6c, 0xa0, 0xbd, 0x53, 0xa3, 0x70, 0x78, 0x6a, 0x14, 0xfe, 0x38, 0x35, 0x0a, 0x9f, + 0x3b, 0x29, 0x9f, 0x79, 0xac, 0x8a, 0x3d, 0x7c, 0x46, 0xb9, 0x17, 0x17, 0xde, 0x4e, 0x95, 0x56, + 0xa6, 0xd3, 0x2d, 0x2b, 0x4f, 0xbc, 0xff, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x03, 0xac, + 0x64, 0xc0, 0x09, 0x00, 0x00, } func (this *QueryParamsRequest) VerboseEqual(that interface{}) error { @@ -1660,18 +1660,18 @@ const _ = grpc.SupportPackageIsVersion4 // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type QueryClient interface { - // Params queries all parameters of the pricefeed module. - Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) - // Price queries price details for a pair - Price(ctx context.Context, in *QueryPriceRequest, opts ...grpc.CallOption) (*QueryPriceResponse, error) - // Prices queries all prices - Prices(ctx context.Context, in *QueryPricesRequest, opts ...grpc.CallOption) (*QueryPricesResponse, error) - // RawPrices queries all raw prices for an asset pair - RawPrices(ctx context.Context, in *QueryRawPricesRequest, opts ...grpc.CallOption) (*QueryRawPricesResponse, error) - // Oracles queries all oracles for an asset pair - Oracles(ctx context.Context, in *QueryOraclesRequest, opts ...grpc.CallOption) (*QueryOraclesResponse, error) - // Pairs queries all pairs - Pairs(ctx context.Context, in *QueryPairsRequest, opts ...grpc.CallOption) (*QueryPairsResponse, error) + // QueryParams queries all parameters of the pricefeed module. + QueryParams(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) + // QueryPrice queries price details for a pair + QueryPrice(ctx context.Context, in *QueryPriceRequest, opts ...grpc.CallOption) (*QueryPriceResponse, error) + // QueryPrices queries all prices + QueryPrices(ctx context.Context, in *QueryPricesRequest, opts ...grpc.CallOption) (*QueryPricesResponse, error) + // QueryRawPrices queries all raw prices for an asset pair + QueryRawPrices(ctx context.Context, in *QueryRawPricesRequest, opts ...grpc.CallOption) (*QueryRawPricesResponse, error) + // QueryOracles queries all oracles for an asset pair + QueryOracles(ctx context.Context, in *QueryOraclesRequest, opts ...grpc.CallOption) (*QueryOraclesResponse, error) + // QueryPairs queries all pairs + QueryPairs(ctx context.Context, in *QueryPairsRequest, opts ...grpc.CallOption) (*QueryPairsResponse, error) } type queryClient struct { @@ -1682,54 +1682,54 @@ func NewQueryClient(cc grpc1.ClientConn) QueryClient { return &queryClient{cc} } -func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { +func (c *queryClient) QueryParams(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { out := new(QueryParamsResponse) - err := c.cc.Invoke(ctx, "/NibiruChain.pricefeed.v1.Query/Params", in, out, opts...) + err := c.cc.Invoke(ctx, "/nibiru.pricefeed.v1.Query/QueryParams", in, out, opts...) if err != nil { return nil, err } return out, nil } -func (c *queryClient) Price(ctx context.Context, in *QueryPriceRequest, opts ...grpc.CallOption) (*QueryPriceResponse, error) { +func (c *queryClient) QueryPrice(ctx context.Context, in *QueryPriceRequest, opts ...grpc.CallOption) (*QueryPriceResponse, error) { out := new(QueryPriceResponse) - err := c.cc.Invoke(ctx, "/NibiruChain.pricefeed.v1.Query/Price", in, out, opts...) + err := c.cc.Invoke(ctx, "/nibiru.pricefeed.v1.Query/QueryPrice", in, out, opts...) if err != nil { return nil, err } return out, nil } -func (c *queryClient) Prices(ctx context.Context, in *QueryPricesRequest, opts ...grpc.CallOption) (*QueryPricesResponse, error) { +func (c *queryClient) QueryPrices(ctx context.Context, in *QueryPricesRequest, opts ...grpc.CallOption) (*QueryPricesResponse, error) { out := new(QueryPricesResponse) - err := c.cc.Invoke(ctx, "/NibiruChain.pricefeed.v1.Query/Prices", in, out, opts...) + err := c.cc.Invoke(ctx, "/nibiru.pricefeed.v1.Query/QueryPrices", in, out, opts...) if err != nil { return nil, err } return out, nil } -func (c *queryClient) RawPrices(ctx context.Context, in *QueryRawPricesRequest, opts ...grpc.CallOption) (*QueryRawPricesResponse, error) { +func (c *queryClient) QueryRawPrices(ctx context.Context, in *QueryRawPricesRequest, opts ...grpc.CallOption) (*QueryRawPricesResponse, error) { out := new(QueryRawPricesResponse) - err := c.cc.Invoke(ctx, "/NibiruChain.pricefeed.v1.Query/RawPrices", in, out, opts...) + err := c.cc.Invoke(ctx, "/nibiru.pricefeed.v1.Query/QueryRawPrices", in, out, opts...) if err != nil { return nil, err } return out, nil } -func (c *queryClient) Oracles(ctx context.Context, in *QueryOraclesRequest, opts ...grpc.CallOption) (*QueryOraclesResponse, error) { +func (c *queryClient) QueryOracles(ctx context.Context, in *QueryOraclesRequest, opts ...grpc.CallOption) (*QueryOraclesResponse, error) { out := new(QueryOraclesResponse) - err := c.cc.Invoke(ctx, "/NibiruChain.pricefeed.v1.Query/Oracles", in, out, opts...) + err := c.cc.Invoke(ctx, "/nibiru.pricefeed.v1.Query/QueryOracles", in, out, opts...) if err != nil { return nil, err } return out, nil } -func (c *queryClient) Pairs(ctx context.Context, in *QueryPairsRequest, opts ...grpc.CallOption) (*QueryPairsResponse, error) { +func (c *queryClient) QueryPairs(ctx context.Context, in *QueryPairsRequest, opts ...grpc.CallOption) (*QueryPairsResponse, error) { out := new(QueryPairsResponse) - err := c.cc.Invoke(ctx, "/NibiruChain.pricefeed.v1.Query/Pairs", in, out, opts...) + err := c.cc.Invoke(ctx, "/nibiru.pricefeed.v1.Query/QueryPairs", in, out, opts...) if err != nil { return nil, err } @@ -1738,182 +1738,182 @@ func (c *queryClient) Pairs(ctx context.Context, in *QueryPairsRequest, opts ... // QueryServer is the server API for Query service. type QueryServer interface { - // Params queries all parameters of the pricefeed module. - Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) - // Price queries price details for a pair - Price(context.Context, *QueryPriceRequest) (*QueryPriceResponse, error) - // Prices queries all prices - Prices(context.Context, *QueryPricesRequest) (*QueryPricesResponse, error) - // RawPrices queries all raw prices for an asset pair - RawPrices(context.Context, *QueryRawPricesRequest) (*QueryRawPricesResponse, error) - // Oracles queries all oracles for an asset pair - Oracles(context.Context, *QueryOraclesRequest) (*QueryOraclesResponse, error) - // Pairs queries all pairs - Pairs(context.Context, *QueryPairsRequest) (*QueryPairsResponse, error) + // QueryParams queries all parameters of the pricefeed module. + QueryParams(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) + // QueryPrice queries price details for a pair + QueryPrice(context.Context, *QueryPriceRequest) (*QueryPriceResponse, error) + // QueryPrices queries all prices + QueryPrices(context.Context, *QueryPricesRequest) (*QueryPricesResponse, error) + // QueryRawPrices queries all raw prices for an asset pair + QueryRawPrices(context.Context, *QueryRawPricesRequest) (*QueryRawPricesResponse, error) + // QueryOracles queries all oracles for an asset pair + QueryOracles(context.Context, *QueryOraclesRequest) (*QueryOraclesResponse, error) + // QueryPairs queries all pairs + QueryPairs(context.Context, *QueryPairsRequest) (*QueryPairsResponse, error) } // UnimplementedQueryServer can be embedded to have forward compatible implementations. type UnimplementedQueryServer struct { } -func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") +func (*UnimplementedQueryServer) QueryParams(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryParams not implemented") } -func (*UnimplementedQueryServer) Price(ctx context.Context, req *QueryPriceRequest) (*QueryPriceResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Price not implemented") +func (*UnimplementedQueryServer) QueryPrice(ctx context.Context, req *QueryPriceRequest) (*QueryPriceResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryPrice not implemented") } -func (*UnimplementedQueryServer) Prices(ctx context.Context, req *QueryPricesRequest) (*QueryPricesResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Prices not implemented") +func (*UnimplementedQueryServer) QueryPrices(ctx context.Context, req *QueryPricesRequest) (*QueryPricesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryPrices not implemented") } -func (*UnimplementedQueryServer) RawPrices(ctx context.Context, req *QueryRawPricesRequest) (*QueryRawPricesResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method RawPrices not implemented") +func (*UnimplementedQueryServer) QueryRawPrices(ctx context.Context, req *QueryRawPricesRequest) (*QueryRawPricesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryRawPrices not implemented") } -func (*UnimplementedQueryServer) Oracles(ctx context.Context, req *QueryOraclesRequest) (*QueryOraclesResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Oracles not implemented") +func (*UnimplementedQueryServer) QueryOracles(ctx context.Context, req *QueryOraclesRequest) (*QueryOraclesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryOracles not implemented") } -func (*UnimplementedQueryServer) Pairs(ctx context.Context, req *QueryPairsRequest) (*QueryPairsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Pairs not implemented") +func (*UnimplementedQueryServer) QueryPairs(ctx context.Context, req *QueryPairsRequest) (*QueryPairsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryPairs not implemented") } func RegisterQueryServer(s grpc1.Server, srv QueryServer) { s.RegisterService(&_Query_serviceDesc, srv) } -func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _Query_QueryParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryParamsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(QueryServer).Params(ctx, in) + return srv.(QueryServer).QueryParams(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/NibiruChain.pricefeed.v1.Query/Params", + FullMethod: "/nibiru.pricefeed.v1.Query/QueryParams", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) + return srv.(QueryServer).QueryParams(ctx, req.(*QueryParamsRequest)) } return interceptor(ctx, in, info, handler) } -func _Query_Price_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _Query_QueryPrice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryPriceRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(QueryServer).Price(ctx, in) + return srv.(QueryServer).QueryPrice(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/NibiruChain.pricefeed.v1.Query/Price", + FullMethod: "/nibiru.pricefeed.v1.Query/QueryPrice", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).Price(ctx, req.(*QueryPriceRequest)) + return srv.(QueryServer).QueryPrice(ctx, req.(*QueryPriceRequest)) } return interceptor(ctx, in, info, handler) } -func _Query_Prices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _Query_QueryPrices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryPricesRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(QueryServer).Prices(ctx, in) + return srv.(QueryServer).QueryPrices(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/NibiruChain.pricefeed.v1.Query/Prices", + FullMethod: "/nibiru.pricefeed.v1.Query/QueryPrices", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).Prices(ctx, req.(*QueryPricesRequest)) + return srv.(QueryServer).QueryPrices(ctx, req.(*QueryPricesRequest)) } return interceptor(ctx, in, info, handler) } -func _Query_RawPrices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _Query_QueryRawPrices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryRawPricesRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(QueryServer).RawPrices(ctx, in) + return srv.(QueryServer).QueryRawPrices(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/NibiruChain.pricefeed.v1.Query/RawPrices", + FullMethod: "/nibiru.pricefeed.v1.Query/QueryRawPrices", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).RawPrices(ctx, req.(*QueryRawPricesRequest)) + return srv.(QueryServer).QueryRawPrices(ctx, req.(*QueryRawPricesRequest)) } return interceptor(ctx, in, info, handler) } -func _Query_Oracles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _Query_QueryOracles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryOraclesRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(QueryServer).Oracles(ctx, in) + return srv.(QueryServer).QueryOracles(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/NibiruChain.pricefeed.v1.Query/Oracles", + FullMethod: "/nibiru.pricefeed.v1.Query/QueryOracles", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).Oracles(ctx, req.(*QueryOraclesRequest)) + return srv.(QueryServer).QueryOracles(ctx, req.(*QueryOraclesRequest)) } return interceptor(ctx, in, info, handler) } -func _Query_Pairs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _Query_QueryPairs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryPairsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(QueryServer).Pairs(ctx, in) + return srv.(QueryServer).QueryPairs(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/NibiruChain.pricefeed.v1.Query/Pairs", + FullMethod: "/nibiru.pricefeed.v1.Query/QueryPairs", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).Pairs(ctx, req.(*QueryPairsRequest)) + return srv.(QueryServer).QueryPairs(ctx, req.(*QueryPairsRequest)) } return interceptor(ctx, in, info, handler) } var _Query_serviceDesc = grpc.ServiceDesc{ - ServiceName: "NibiruChain.pricefeed.v1.Query", + ServiceName: "nibiru.pricefeed.v1.Query", HandlerType: (*QueryServer)(nil), Methods: []grpc.MethodDesc{ { - MethodName: "Params", - Handler: _Query_Params_Handler, + MethodName: "QueryParams", + Handler: _Query_QueryParams_Handler, }, { - MethodName: "Price", - Handler: _Query_Price_Handler, + MethodName: "QueryPrice", + Handler: _Query_QueryPrice_Handler, }, { - MethodName: "Prices", - Handler: _Query_Prices_Handler, + MethodName: "QueryPrices", + Handler: _Query_QueryPrices_Handler, }, { - MethodName: "RawPrices", - Handler: _Query_RawPrices_Handler, + MethodName: "QueryRawPrices", + Handler: _Query_QueryRawPrices_Handler, }, { - MethodName: "Oracles", - Handler: _Query_Oracles_Handler, + MethodName: "QueryOracles", + Handler: _Query_QueryOracles_Handler, }, { - MethodName: "Pairs", - Handler: _Query_Pairs_Handler, + MethodName: "QueryPairs", + Handler: _Query_QueryPairs_Handler, }, }, Streams: []grpc.StreamDesc{}, diff --git a/x/pricefeed/types/query.pb.gw.go b/x/pricefeed/types/query.pb.gw.go index 43545fad5..941f3d8f9 100644 --- a/x/pricefeed/types/query.pb.gw.go +++ b/x/pricefeed/types/query.pb.gw.go @@ -31,25 +31,25 @@ var _ = runtime.String var _ = utilities.NewDoubleArray var _ = descriptor.ForMessage -func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { +func request_Query_QueryParams_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryParamsRequest var metadata runtime.ServerMetadata - msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + msg, err := client.QueryParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } -func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { +func local_request_Query_QueryParams_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryParamsRequest var metadata runtime.ServerMetadata - msg, err := server.Params(ctx, &protoReq) + msg, err := server.QueryParams(ctx, &protoReq) return msg, metadata, err } -func request_Query_Price_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { +func request_Query_QueryPrice_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryPriceRequest var metadata runtime.ServerMetadata @@ -71,12 +71,12 @@ func request_Query_Price_0(ctx context.Context, marshaler runtime.Marshaler, cli return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pair_id", err) } - msg, err := client.Price(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + msg, err := client.QueryPrice(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } -func local_request_Query_Price_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { +func local_request_Query_QueryPrice_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryPriceRequest var metadata runtime.ServerMetadata @@ -98,30 +98,30 @@ func local_request_Query_Price_0(ctx context.Context, marshaler runtime.Marshale return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pair_id", err) } - msg, err := server.Price(ctx, &protoReq) + msg, err := server.QueryPrice(ctx, &protoReq) return msg, metadata, err } -func request_Query_Prices_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { +func request_Query_QueryPrices_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryPricesRequest var metadata runtime.ServerMetadata - msg, err := client.Prices(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + msg, err := client.QueryPrices(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } -func local_request_Query_Prices_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { +func local_request_Query_QueryPrices_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryPricesRequest var metadata runtime.ServerMetadata - msg, err := server.Prices(ctx, &protoReq) + msg, err := server.QueryPrices(ctx, &protoReq) return msg, metadata, err } -func request_Query_RawPrices_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { +func request_Query_QueryRawPrices_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryRawPricesRequest var metadata runtime.ServerMetadata @@ -143,12 +143,12 @@ func request_Query_RawPrices_0(ctx context.Context, marshaler runtime.Marshaler, return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pair_id", err) } - msg, err := client.RawPrices(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + msg, err := client.QueryRawPrices(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } -func local_request_Query_RawPrices_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { +func local_request_Query_QueryRawPrices_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryRawPricesRequest var metadata runtime.ServerMetadata @@ -170,12 +170,12 @@ func local_request_Query_RawPrices_0(ctx context.Context, marshaler runtime.Mars return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pair_id", err) } - msg, err := server.RawPrices(ctx, &protoReq) + msg, err := server.QueryRawPrices(ctx, &protoReq) return msg, metadata, err } -func request_Query_Oracles_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { +func request_Query_QueryOracles_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryOraclesRequest var metadata runtime.ServerMetadata @@ -197,12 +197,12 @@ func request_Query_Oracles_0(ctx context.Context, marshaler runtime.Marshaler, c return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pair_id", err) } - msg, err := client.Oracles(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + msg, err := client.QueryOracles(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } -func local_request_Query_Oracles_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { +func local_request_Query_QueryOracles_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryOraclesRequest var metadata runtime.ServerMetadata @@ -224,25 +224,25 @@ func local_request_Query_Oracles_0(ctx context.Context, marshaler runtime.Marsha return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pair_id", err) } - msg, err := server.Oracles(ctx, &protoReq) + msg, err := server.QueryOracles(ctx, &protoReq) return msg, metadata, err } -func request_Query_Pairs_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { +func request_Query_QueryPairs_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryPairsRequest var metadata runtime.ServerMetadata - msg, err := client.Pairs(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + msg, err := client.QueryPairs(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } -func local_request_Query_Pairs_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { +func local_request_Query_QueryPairs_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryPairsRequest var metadata runtime.ServerMetadata - msg, err := server.Pairs(ctx, &protoReq) + msg, err := server.QueryPairs(ctx, &protoReq) return msg, metadata, err } @@ -253,7 +253,7 @@ func local_request_Query_Pairs_0(ctx context.Context, marshaler runtime.Marshale // Note that using this registration option will cause many gRPC library features (such as grpc.SendHeader, etc) to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { - mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -262,18 +262,18 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_QueryParams_0(rctx, inboundMarshaler, server, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_Price_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryPrice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -282,18 +282,18 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_Price_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_QueryPrice_0(rctx, inboundMarshaler, server, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_Price_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryPrice_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_Prices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryPrices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -302,18 +302,18 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_Prices_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_QueryPrices_0(rctx, inboundMarshaler, server, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_Prices_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryPrices_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_RawPrices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryRawPrices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -322,18 +322,18 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_RawPrices_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_QueryRawPrices_0(rctx, inboundMarshaler, server, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_RawPrices_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryRawPrices_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_Oracles_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryOracles_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -342,18 +342,18 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_Oracles_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_QueryOracles_0(rctx, inboundMarshaler, server, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_Oracles_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryOracles_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_Pairs_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryPairs_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -362,14 +362,14 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_Pairs_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_QueryPairs_0(rctx, inboundMarshaler, server, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_Pairs_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryPairs_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -414,7 +414,7 @@ func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc // "QueryClient" to call the correct interceptors. func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { - mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -423,18 +423,18 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_QueryParams_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_Price_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryPrice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -443,18 +443,18 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_Price_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_QueryPrice_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_Price_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryPrice_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_Prices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryPrices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -463,18 +463,18 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_Prices_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_QueryPrices_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_Prices_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryPrices_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_RawPrices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryRawPrices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -483,18 +483,18 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_RawPrices_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_QueryRawPrices_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_RawPrices_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryRawPrices_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_Oracles_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryOracles_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -503,18 +503,18 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_Oracles_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_QueryOracles_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_Oracles_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryOracles_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_Pairs_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryPairs_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -523,14 +523,14 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_Pairs_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_QueryPairs_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_Pairs_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryPairs_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -538,29 +538,29 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } var ( - pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"nibiru", "pricefeed", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_QueryParams_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"nibiru", "pricefeed", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_Price_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"nibiru", "pricefeed", "v1beta1", "prices", "pair_id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_QueryPrice_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"nibiru", "pricefeed", "v1beta1", "prices", "pair_id"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_Prices_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"nibiru", "pricefeed", "v1beta1", "prices"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_QueryPrices_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"nibiru", "pricefeed", "v1beta1", "prices"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_RawPrices_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"nibiru", "pricefeed", "v1beta1", "rawprices", "pair_id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_QueryRawPrices_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"nibiru", "pricefeed", "v1beta1", "rawprices", "pair_id"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_Oracles_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"nibiru", "pricefeed", "v1beta1", "oracles", "pair_id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_QueryOracles_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"nibiru", "pricefeed", "v1beta1", "oracles", "pair_id"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_Pairs_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"nibiru", "pricefeed", "v1beta1", "pairs"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_QueryPairs_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"nibiru", "pricefeed", "v1beta1", "pairs"}, "", runtime.AssumeColonVerbOpt(false))) ) var ( - forward_Query_Params_0 = runtime.ForwardResponseMessage + forward_Query_QueryParams_0 = runtime.ForwardResponseMessage - forward_Query_Price_0 = runtime.ForwardResponseMessage + forward_Query_QueryPrice_0 = runtime.ForwardResponseMessage - forward_Query_Prices_0 = runtime.ForwardResponseMessage + forward_Query_QueryPrices_0 = runtime.ForwardResponseMessage - forward_Query_RawPrices_0 = runtime.ForwardResponseMessage + forward_Query_QueryRawPrices_0 = runtime.ForwardResponseMessage - forward_Query_Oracles_0 = runtime.ForwardResponseMessage + forward_Query_QueryOracles_0 = runtime.ForwardResponseMessage - forward_Query_Pairs_0 = runtime.ForwardResponseMessage + forward_Query_QueryPairs_0 = runtime.ForwardResponseMessage ) diff --git a/x/pricefeed/types/store.go b/x/pricefeed/types/store.go index 9308e6047..05de97f67 100644 --- a/x/pricefeed/types/store.go +++ b/x/pricefeed/types/store.go @@ -10,15 +10,18 @@ import ( // Parameter keys var ( - KeyPairs = []byte("Pairs") - DefaultPairs = []Pair{ - {Token0: common.CollDenom, Token1: common.StableDenom, Active: true}, - {Token0: common.GovDenom, Token1: common.StableDenom, Active: true}, + DefaultPairs = common.AssetPairs{ + common.PairGovStable, + common.PairCollStable, + common.PairBTCStable, + common.PairETHStable, } ) // NewParams creates a new AssetParams object -func NewParams(pairs []Pair) Params { +func NewParams( + pairs common.AssetPairs, +) Params { return Params{ Pairs: pairs, } @@ -38,20 +41,29 @@ func ParamKeyTable() paramtypes.KeyTable { // pairs of pricefeed module's parameters. func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { return paramtypes.ParamSetPairs{ - paramtypes.NewParamSetPair(KeyPairs, &p.Pairs, validatePairParams), + paramtypes.NewParamSetPair([]byte("Pairs"), &p.Pairs, validateParamPairs), } } // Validate ensure that params have valid values func (p Params) Validate() error { - return validatePairParams(p.Pairs) + err := validateParamPairs(p.Pairs) + if err != nil { + return err + } + return nil } -func validatePairParams(i interface{}) error { - markets, ok := i.(Pairs) +func validateParamPairs(i interface{}) error { + pairs, ok := i.([]common.AssetPair) if !ok { return fmt.Errorf("invalid parameter type: %T", i) } + for _, pair := range pairs { + if err := pair.Validate(); err != nil { + return err + } + } - return markets.Validate() + return nil } diff --git a/x/pricefeed/types/tx.pb.go b/x/pricefeed/types/tx.pb.go index 6199a5e2a..c3d0d6385 100644 --- a/x/pricefeed/types/tx.pb.go +++ b/x/pricefeed/types/tx.pb.go @@ -224,47 +224,47 @@ func (m *EventPairPriceUpdated) GetPairId() string { } func init() { - proto.RegisterType((*MsgPostPrice)(nil), "NibiruChain.pricefeed.v1.MsgPostPrice") - proto.RegisterType((*MsgPostPriceResponse)(nil), "NibiruChain.pricefeed.v1.MsgPostPriceResponse") - proto.RegisterType((*EventOracleUpdatePrice)(nil), "NibiruChain.pricefeed.v1.EventOracleUpdatePrice") - proto.RegisterType((*EventPairPriceUpdated)(nil), "NibiruChain.pricefeed.v1.EventPairPriceUpdated") + proto.RegisterType((*MsgPostPrice)(nil), "nibiru.pricefeed.v1.MsgPostPrice") + proto.RegisterType((*MsgPostPriceResponse)(nil), "nibiru.pricefeed.v1.MsgPostPriceResponse") + proto.RegisterType((*EventOracleUpdatePrice)(nil), "nibiru.pricefeed.v1.EventOracleUpdatePrice") + proto.RegisterType((*EventPairPriceUpdated)(nil), "nibiru.pricefeed.v1.EventPairPriceUpdated") } func init() { proto.RegisterFile("pricefeed/tx.proto", fileDescriptor_27d54c954ce5f810) } var fileDescriptor_27d54c954ce5f810 = []byte{ - // 486 bytes of a gzipped FileDescriptorProto + // 485 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x93, 0xcf, 0x6f, 0xd3, 0x30, - 0x14, 0xc7, 0xe3, 0xb5, 0x2b, 0xd4, 0x70, 0xb2, 0x46, 0x89, 0xaa, 0xc9, 0x99, 0x22, 0x34, 0xed, - 0x32, 0x9b, 0x8e, 0x1b, 0xe2, 0x54, 0xc6, 0x81, 0x43, 0xa1, 0x54, 0x70, 0xe1, 0x82, 0xd2, 0xc4, - 0xcd, 0xac, 0x2d, 0x79, 0x56, 0xec, 0x4e, 0xdd, 0x09, 0x89, 0x13, 0xdc, 0x86, 0xf8, 0x07, 0x38, - 0xf2, 0xa7, 0xec, 0x38, 0x09, 0x09, 0x21, 0x84, 0xc6, 0x68, 0xf9, 0x43, 0x50, 0x9c, 0xa4, 0x0b, - 0x48, 0x93, 0xf8, 0x71, 0x8a, 0xbf, 0xcf, 0xdf, 0xf7, 0xfc, 0x3e, 0x7e, 0x0e, 0x26, 0x2a, 0x93, - 0xa1, 0x98, 0x08, 0x11, 0x71, 0x33, 0x63, 0x2a, 0x03, 0x03, 0xc4, 0x7d, 0x24, 0xc7, 0x32, 0x9b, - 0xde, 0xdf, 0x0b, 0x64, 0xca, 0x96, 0xfb, 0xec, 0xb0, 0xd7, 0x5d, 0x8b, 0x21, 0x06, 0x6b, 0xe2, - 0xf9, 0xaa, 0xf0, 0x77, 0xbd, 0x18, 0x20, 0x3e, 0x10, 0xdc, 0xaa, 0xf1, 0x74, 0xc2, 0x8d, 0x4c, - 0x84, 0x36, 0x41, 0xa2, 0x4a, 0xc3, 0x7a, 0x69, 0x08, 0x94, 0xe4, 0x41, 0x9a, 0x82, 0x09, 0x8c, - 0x84, 0x54, 0x17, 0xbb, 0xfe, 0x57, 0x84, 0xaf, 0x0f, 0x74, 0x3c, 0x04, 0x6d, 0x86, 0xf9, 0x61, - 0x84, 0xe0, 0xe6, 0x24, 0x83, 0xc4, 0x45, 0x1b, 0x68, 0xab, 0x3d, 0xb2, 0x6b, 0xd2, 0xc1, 0x2d, - 0x03, 0xfb, 0x22, 0xbd, 0xed, 0xae, 0xd8, 0x68, 0xa9, 0x96, 0xf1, 0x9e, 0xdb, 0xa8, 0xc5, 0x7b, - 0x64, 0x17, 0xaf, 0xda, 0xce, 0xdd, 0x66, 0x1e, 0xee, 0xb3, 0x93, 0x33, 0xcf, 0xf9, 0x72, 0xe6, - 0x6d, 0xc6, 0xd2, 0xec, 0x4d, 0xc7, 0x2c, 0x84, 0x84, 0x87, 0xa0, 0x13, 0xd0, 0xe5, 0x67, 0x5b, - 0x47, 0xfb, 0xdc, 0x1c, 0x29, 0xa1, 0xd9, 0xae, 0x08, 0x47, 0x45, 0x32, 0xb9, 0x87, 0x5b, 0x62, - 0xa6, 0x64, 0x76, 0xe4, 0xae, 0x6e, 0xa0, 0xad, 0x6b, 0x3b, 0x5d, 0x56, 0x90, 0xb0, 0x0a, 0x95, - 0x3d, 0xad, 0x50, 0xfb, 0x57, 0xf3, 0x23, 0x8e, 0xbf, 0x79, 0x68, 0x54, 0xe6, 0xdc, 0x6d, 0xbe, - 0x7e, 0xef, 0x39, 0x7e, 0x07, 0xaf, 0xd5, 0xe9, 0x46, 0x42, 0x2b, 0x48, 0xb5, 0xf0, 0x3f, 0x21, - 0xdc, 0x79, 0x70, 0x28, 0x52, 0xf3, 0x38, 0x0b, 0xc2, 0x03, 0xf1, 0x4c, 0x45, 0x81, 0x11, 0xc5, - 0x05, 0xdc, 0xc4, 0x57, 0x54, 0x20, 0xb3, 0x17, 0x32, 0x2a, 0xef, 0xa0, 0x95, 0xcb, 0x87, 0x51, - 0x4e, 0x0b, 0xd6, 0x5d, 0xdd, 0x42, 0xa1, 0xc8, 0x00, 0x63, 0x9b, 0x50, 0x20, 0x37, 0xfe, 0x09, - 0xb9, 0x9d, 0x57, 0x18, 0xfe, 0x86, 0xdd, 0xfc, 0x7b, 0x6c, 0xff, 0x25, 0xbe, 0x61, 0xb9, 0x86, - 0x55, 0xbd, 0x02, 0x2d, 0xba, 0x1c, 0xeb, 0xd7, 0xf6, 0x57, 0xfe, 0xb3, 0xfd, 0x9d, 0xb7, 0x08, - 0x37, 0x06, 0x3a, 0x26, 0x6f, 0x10, 0x6e, 0x5f, 0xbc, 0xaa, 0x4d, 0x76, 0xd9, 0xb3, 0x66, 0xf5, - 0xf9, 0x74, 0xd9, 0x9f, 0xf9, 0x96, 0x73, 0xbc, 0xf5, 0xea, 0xe3, 0x8f, 0x77, 0x2b, 0xd4, 0x5f, - 0xe7, 0xa9, 0xcd, 0xe3, 0x17, 0x7f, 0x94, 0x02, 0x6d, 0xb6, 0xad, 0xec, 0x3f, 0x39, 0xff, 0x4e, - 0xd1, 0x87, 0x39, 0x45, 0x27, 0x73, 0x8a, 0x4e, 0xe7, 0x14, 0x9d, 0xcf, 0x29, 0x3a, 0x5e, 0x50, - 0xe7, 0x74, 0x41, 0x9d, 0xcf, 0x0b, 0xea, 0x3c, 0xe7, 0x35, 0xd0, 0x5a, 0x07, 0x55, 0xd5, 0x59, - 0xad, 0xae, 0xa5, 0x1e, 0xb7, 0xec, 0x34, 0xee, 0xfc, 0x0c, 0x00, 0x00, 0xff, 0xff, 0x36, 0x69, - 0x9f, 0x5d, 0xc3, 0x03, 0x00, 0x00, + 0x14, 0xc7, 0xe3, 0xb6, 0x2b, 0xd4, 0x70, 0x32, 0xa3, 0x44, 0xd5, 0xe4, 0x8c, 0x08, 0xa1, 0x71, + 0x98, 0x4d, 0xc7, 0x0d, 0x71, 0x2a, 0xe3, 0xc0, 0xa1, 0x50, 0x2a, 0xb8, 0x70, 0x41, 0x69, 0xe2, + 0x66, 0xd6, 0x96, 0xd8, 0x8a, 0xdd, 0xa9, 0x3b, 0x4d, 0xe2, 0x80, 0x38, 0x4e, 0xe2, 0x1f, 0xe0, + 0xc8, 0x9f, 0xb2, 0xe3, 0x24, 0x24, 0x84, 0x10, 0x1a, 0x23, 0xe5, 0x0f, 0x41, 0xb1, 0x93, 0x2e, + 0x20, 0x10, 0x02, 0x4e, 0xf1, 0xfb, 0xf5, 0xf5, 0xfb, 0xbc, 0xe7, 0x40, 0x24, 0x33, 0x1e, 0xb2, + 0x29, 0x63, 0x11, 0xd5, 0x73, 0x22, 0x33, 0xa1, 0x05, 0xba, 0x92, 0xf2, 0x09, 0xcf, 0x66, 0x64, + 0x19, 0x22, 0xfb, 0xfd, 0xde, 0x6a, 0x2c, 0x62, 0x61, 0xe2, 0xb4, 0x38, 0xd9, 0xd4, 0x9e, 0x17, + 0x0b, 0x11, 0xef, 0x31, 0x6a, 0xac, 0xc9, 0x6c, 0x4a, 0x35, 0x4f, 0x98, 0xd2, 0x41, 0x22, 0xcb, + 0x84, 0xb5, 0x32, 0x21, 0x90, 0x9c, 0x06, 0x69, 0x2a, 0x74, 0xa0, 0xb9, 0x48, 0x95, 0x8d, 0xfa, + 0x9f, 0x01, 0xbc, 0x3c, 0x54, 0xf1, 0x48, 0x28, 0x3d, 0x2a, 0x2e, 0x43, 0x08, 0xb6, 0xa6, 0x99, + 0x48, 0x5c, 0xb0, 0x0e, 0x36, 0x3a, 0x63, 0x73, 0x46, 0x5d, 0xd8, 0xd6, 0x62, 0x97, 0xa5, 0xb7, + 0xdd, 0x86, 0xf1, 0x96, 0xd6, 0xd2, 0xdf, 0x77, 0x9b, 0x35, 0x7f, 0x1f, 0x6d, 0xc3, 0x15, 0xd3, + 0xb9, 0xdb, 0x2a, 0xdc, 0x03, 0x72, 0x7c, 0xea, 0x39, 0x9f, 0x4e, 0xbd, 0x9b, 0x31, 0xd7, 0x3b, + 0xb3, 0x09, 0x09, 0x45, 0x42, 0x43, 0xa1, 0x12, 0xa1, 0xca, 0xcf, 0xa6, 0x8a, 0x76, 0xa9, 0x3e, + 0x90, 0x4c, 0x91, 0x6d, 0x16, 0x8e, 0x6d, 0x31, 0xba, 0x07, 0xdb, 0x6c, 0x2e, 0x79, 0x76, 0xe0, + 0xae, 0xac, 0x83, 0x8d, 0x4b, 0x5b, 0x3d, 0x62, 0x49, 0x48, 0x85, 0x4a, 0x9e, 0x56, 0xa8, 0x83, + 0x8b, 0xc5, 0x15, 0x47, 0x5f, 0x3c, 0x30, 0x2e, 0x6b, 0xee, 0xb6, 0x5e, 0xbf, 0xf5, 0x1c, 0xbf, + 0x0b, 0x57, 0xeb, 0x74, 0x63, 0xa6, 0xa4, 0x48, 0x15, 0xf3, 0x3f, 0x00, 0xd8, 0x7d, 0xb0, 0xcf, + 0x52, 0xfd, 0x38, 0x0b, 0xc2, 0x3d, 0xf6, 0x4c, 0x46, 0x81, 0x66, 0x76, 0x00, 0xd7, 0xe0, 0x05, + 0x19, 0xf0, 0xec, 0x05, 0x8f, 0xca, 0x19, 0xb4, 0x0b, 0xf3, 0x61, 0x54, 0xd0, 0x0a, 0x93, 0x5d, + 0x4d, 0xc1, 0x5a, 0x68, 0x08, 0xa1, 0x29, 0xb0, 0xc8, 0xcd, 0x7f, 0x42, 0xee, 0x14, 0x0a, 0xa3, + 0x9f, 0xb0, 0x5b, 0x7f, 0x8f, 0xed, 0x1f, 0xc2, 0xab, 0x86, 0x6b, 0x54, 0xe9, 0x59, 0xb4, 0xe8, + 0xf7, 0x58, 0x3f, 0xb6, 0xdf, 0xf8, 0xcf, 0xf6, 0xb7, 0x5e, 0x01, 0xd8, 0x1c, 0xaa, 0x18, 0x1d, + 0xc2, 0xce, 0xf9, 0xa3, 0xba, 0x4e, 0x7e, 0xf1, 0xa0, 0x49, 0x7d, 0x33, 0xbd, 0x5b, 0x7f, 0x4c, + 0x59, 0x2e, 0xef, 0xc6, 0xcb, 0xf7, 0xdf, 0xde, 0x34, 0xb0, 0xbf, 0x46, 0x6d, 0x09, 0x3d, 0xff, + 0x83, 0xa4, 0x50, 0x7a, 0xd3, 0x98, 0x83, 0x27, 0x67, 0x5f, 0x31, 0x78, 0x97, 0x63, 0x70, 0x9c, + 0x63, 0x70, 0x92, 0x63, 0x70, 0x96, 0x63, 0x70, 0xb4, 0xc0, 0xce, 0xc9, 0x02, 0x3b, 0x1f, 0x17, + 0xd8, 0x79, 0x4e, 0x6b, 0x74, 0x8f, 0x8c, 0xd2, 0xfd, 0x9d, 0x80, 0xa7, 0x95, 0xea, 0xbc, 0xa6, + 0x6b, 0x50, 0x27, 0x6d, 0xb3, 0x82, 0x3b, 0xdf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x95, 0x73, 0xaf, + 0x70, 0xb3, 0x03, 0x00, 0x00, } func (this *MsgPostPrice) VerboseEqual(that interface{}) error { @@ -552,7 +552,7 @@ func NewMsgClient(cc grpc1.ClientConn) MsgClient { func (c *msgClient) PostPrice(ctx context.Context, in *MsgPostPrice, opts ...grpc.CallOption) (*MsgPostPriceResponse, error) { out := new(MsgPostPriceResponse) - err := c.cc.Invoke(ctx, "/NibiruChain.pricefeed.v1.Msg/PostPrice", in, out, opts...) + err := c.cc.Invoke(ctx, "/nibiru.pricefeed.v1.Msg/PostPrice", in, out, opts...) if err != nil { return nil, err } @@ -587,7 +587,7 @@ func _Msg_PostPrice_Handler(srv interface{}, ctx context.Context, dec func(inter } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/NibiruChain.pricefeed.v1.Msg/PostPrice", + FullMethod: "/nibiru.pricefeed.v1.Msg/PostPrice", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).PostPrice(ctx, req.(*MsgPostPrice)) @@ -596,7 +596,7 @@ func _Msg_PostPrice_Handler(srv interface{}, ctx context.Context, dec func(inter } var _Msg_serviceDesc = grpc.ServiceDesc{ - ServiceName: "NibiruChain.pricefeed.v1.Msg", + ServiceName: "nibiru.pricefeed.v1.Msg", HandlerType: (*MsgServer)(nil), Methods: []grpc.MethodDesc{ { diff --git a/x/simulation/mod.go b/x/simulation/mod.go index 73fa09118..e501d4d11 100644 --- a/x/simulation/mod.go +++ b/x/simulation/mod.go @@ -58,8 +58,8 @@ func GenAndDeliverTxWithRandFees( return simtypes.NoOpMsg(moduleName, msg.Type(), "message doesn't leave room for fees"), nil, err } - // Only allow fees in common.GovDenom - coins = sdk.NewCoins(sdk.NewCoin(common.GovDenom, coins.AmountOf(common.GovDenom))) + // Only allow fees in common.DenomGov + coins = sdk.NewCoins(sdk.NewCoin(common.DenomGov, coins.AmountOf(common.DenomGov))) fees, err = simtypes.RandomFees(r, ctx, coins) if err != nil { diff --git a/x/stablecoin/abci.go b/x/stablecoin/abci.go index 462188e13..0e29ea7d4 100644 --- a/x/stablecoin/abci.go +++ b/x/stablecoin/abci.go @@ -19,7 +19,7 @@ func EndBlocker(ctx sdk.Context, k keeper.Keeper) { k.SetParams(ctx, params) } - _, err := k.PricefeedKeeper.GetCurrentTWAPPrice(ctx, common.StableDenom, common.CollDenom) + _, err := k.PricefeedKeeper.GetCurrentTWAPPrice(ctx, common.DenomStable, common.DenomColl) if err != nil { params := k.GetParams(ctx) params.IsCollateralRatioValid = false diff --git a/x/stablecoin/abci_test.go b/x/stablecoin/abci_test.go index da8fe8aa8..98f2d0816 100644 --- a/x/stablecoin/abci_test.go +++ b/x/stablecoin/abci_test.go @@ -12,8 +12,8 @@ import ( "github.com/NibiruChain/nibiru/x/epochs" "github.com/NibiruChain/nibiru/x/pricefeed" ptypes "github.com/NibiruChain/nibiru/x/pricefeed/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) type test struct { @@ -30,10 +30,10 @@ func TestEpochInfoChangesBeginBlockerAndInitGenesis(t *testing.T) { tests := []test{ { - Name: "Price higher than peg, wait for correct amount of time", + Name: "Collateral price higher than stable, wait for correct amount of time", InCollRatio: sdk.MustNewDecFromStr("0.8"), price: sdk.MustNewDecFromStr("0.9"), - ExpectedCollRatio: sdk.MustNewDecFromStr("0.8025"), + ExpectedCollRatio: sdk.MustNewDecFromStr("0.7975"), fn: func() { ctx = ctx.WithBlockHeight(2).WithBlockTime(ctx.BlockTime().Add(time.Second)) epochs.BeginBlocker(ctx, app.EpochsKeeper) @@ -72,10 +72,10 @@ func TestEpochInfoChangesBeginBlockerAndInitGenesis(t *testing.T) { }, }, { - Name: "Price higher than peg, and we wait for 2 updates, coll ratio should be updated twice", + Name: "Collateral price higher than stable, and we wait for 2 updates, coll ratio should be updated twice", InCollRatio: sdk.MustNewDecFromStr("0.8"), price: sdk.MustNewDecFromStr("0.9"), - ExpectedCollRatio: sdk.MustNewDecFromStr("0.805"), + ExpectedCollRatio: sdk.MustNewDecFromStr("0.795"), fn: func() { ctx = ctx.WithBlockHeight(2).WithBlockTime(ctx.BlockTime().Add(time.Second)) epochs.BeginBlocker(ctx, app.EpochsKeeper) @@ -88,10 +88,10 @@ func TestEpochInfoChangesBeginBlockerAndInitGenesis(t *testing.T) { }, }, { - Name: "Price higher than peg, and we wait for 2 updates but the last one is too close for update, coll ratio should be updated once", + Name: "Collateral price higher than stable, and we wait for 2 updates but the last one is too close for update, coll ratio should be updated once", InCollRatio: sdk.MustNewDecFromStr("0.8"), price: sdk.MustNewDecFromStr("0.9"), - ExpectedCollRatio: sdk.MustNewDecFromStr("0.8025"), + ExpectedCollRatio: sdk.MustNewDecFromStr("0.7975"), fn: func() { ctx = ctx.WithBlockHeight(2).WithBlockTime(ctx.BlockTime().Add(time.Second)) epochs.BeginBlocker(ctx, app.EpochsKeeper) @@ -108,33 +108,27 @@ func TestEpochInfoChangesBeginBlockerAndInitGenesis(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.Name, func(t *testing.T) { - app, ctx = testutilapp.NewNibiruApp(true) + app, ctx = testapp.NewNibiruAppAndContext(true) ctx = ctx.WithBlockHeight(1) oracle := sample.AccAddress() - markets := ptypes.NewParams([]ptypes.Pair{ - - { - Token0: common.CollDenom, - Token1: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, - Active: true, - }, - }) - + pairs := common.AssetPairs{ + common.PairCollStable, + } + markets := ptypes.NewParams(pairs) app.PricefeedKeeper.SetParams(ctx, markets) + app.PricefeedKeeper.WhitelistOracles(ctx, []sdk.AccAddress{oracle}) _, err := app.PricefeedKeeper.SetPrice( ctx, oracle, - /* token0 */ common.StableDenom, - /* token1 */ common.CollDenom, + pairs[0].String(), /* price */ tc.price, /* expiry */ ctx.BlockTime().UTC().Add(time.Hour*1)) require.NoError(t, err) - err = app.PricefeedKeeper.SetCurrentPrices(ctx, common.StableDenom, common.CollDenom) + err = app.PricefeedKeeper.SetCurrentPrices(ctx, pairs[0].Token0, pairs[0].Token1) require.NoError(t, err) err = app.StablecoinKeeper.SetCollRatio(ctx, tc.InCollRatio) @@ -149,8 +143,7 @@ func TestEpochInfoChangesBeginBlockerAndInitGenesis(t *testing.T) { } func TestEpochInfoChangesCollateralValidity(t *testing.T) { - app, ctx := testutilapp.NewNibiruApp(true) - token0, token1 := common.StableDenom, common.CollDenom + app, ctx := testapp.NewNibiruAppAndContext(true) runBlock := func(duration time.Duration) { ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1).WithBlockTime(ctx.BlockTime().Add(duration)) @@ -164,21 +157,19 @@ func TestEpochInfoChangesCollateralValidity(t *testing.T) { epochs.BeginBlocker(ctx, app.EpochsKeeper) oracle := sample.AccAddress() - markets := ptypes.NewParams([]ptypes.Pair{ - - { - Token0: common.CollDenom, - Token1: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, - Active: true, - }, - }) + pairs := common.AssetPairs{ + {Token0: common.DenomColl, Token1: common.DenomStable}, + } + markets := ptypes.NewParams(pairs) + app.PricefeedKeeper.SetParams(ctx, markets) + app.PricefeedKeeper.WhitelistOracles(ctx, []sdk.AccAddress{oracle}) app.PricefeedKeeper.SetParams(ctx, markets) // Sim set price set the price for one hour - _, err := app.PricefeedKeeper.SetPrice(ctx, oracle, token0, token1, sdk.MustNewDecFromStr("0.9"), ctx.BlockTime().Add(time.Hour)) + _, err := app.PricefeedKeeper.SetPrice( + ctx, oracle, pairs[0].String(), sdk.MustNewDecFromStr("0.9"), ctx.BlockTime().Add(time.Hour)) require.NoError(t, err) - require.NoError(t, app.PricefeedKeeper.SetCurrentPrices(ctx, common.StableDenom, common.CollDenom)) + require.NoError(t, app.PricefeedKeeper.SetCurrentPrices(ctx, pairs[0].Token0, pairs[0].Token1)) require.NoError(t, app.StablecoinKeeper.SetCollRatio(ctx, sdk.MustNewDecFromStr("0.8"))) // Mint block #2 @@ -190,7 +181,8 @@ func TestEpochInfoChangesCollateralValidity(t *testing.T) { require.False(t, app.StablecoinKeeper.GetParams(ctx).IsCollateralRatioValid) // Post price, collateral should be valid again - _, err = app.PricefeedKeeper.SetPrice(ctx, oracle, token0, token1, sdk.MustNewDecFromStr("0.9"), ctx.BlockTime().UTC().Add(time.Hour)) + _, err = app.PricefeedKeeper.SetPrice( + ctx, oracle, pairs[0].String(), sdk.MustNewDecFromStr("0.9"), ctx.BlockTime().UTC().Add(time.Hour)) require.NoError(t, err) // Mint block #4, median price and TWAP are computed again at the end of a new block diff --git a/x/stablecoin/client/cli/cli_test.go b/x/stablecoin/client/cli/cli_test.go index c7202f175..599f8c112 100644 --- a/x/stablecoin/client/cli/cli_test.go +++ b/x/stablecoin/client/cli/cli_test.go @@ -38,33 +38,28 @@ type IntegrationTestSuite struct { // NewPricefeedGen returns an x/pricefeed GenesisState to specify the module parameters. func NewPricefeedGen() *pftypes.GenesisState { - oracle, _ := sdk.AccAddressFromBech32(oracleAddress) + oracle := sdk.MustAccAddressFromBech32(oracleAddress) + pairs := common.AssetPairs{ + common.PairGovStable, common.PairCollStable, + } return &pftypes.GenesisState{ - Params: pftypes.Params{ - Pairs: []pftypes.Pair{ - {Token0: common.GovStablePool.Token0, - Token1: common.GovStablePool.Token1, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - {Token0: common.CollStablePool.Token0, - Token1: common.CollStablePool.Token1, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }, - }, + Params: pftypes.Params{Pairs: pairs}, PostedPrices: []pftypes.PostedPrice{ { - PairID: common.GovStablePool.PairID(), - OracleAddress: oracle, - Price: sdk.NewDec(10), - Expiry: time.Now().Add(1 * time.Hour), + PairID: common.PairGovStable.String(), + Oracle: oracle.String(), + Price: sdk.NewDec(10), + Expiry: time.Now().Add(1 * time.Hour), }, { - PairID: common.CollStablePool.PairID(), - OracleAddress: oracle, - Price: sdk.OneDec(), - Expiry: time.Now().Add(1 * time.Hour), + PairID: common.PairCollStable.String(), + Oracle: oracle.String(), + Price: sdk.OneDec(), + Expiry: time.Now().Add(1 * time.Hour), }, }, + GenesisOracles: []string{oracle.String()}, } } @@ -80,7 +75,9 @@ func (s *IntegrationTestSuite) SetupSuite() { s.T().Log("setting up integration test suite") - s.cfg = testutilcli.DefaultConfig() + encodingConfig := app.MakeTestEncodingConfig() + defaultAppGenesis := app.NewDefaultGenesisState(encodingConfig.Marshaler) + s.cfg = testutilcli.BuildNetworkConfig(defaultAppGenesis) // modification to pay fee with test bond denom "stake" app.SetPrefixes(app.AccountAddressPrefix) @@ -89,7 +86,7 @@ func (s *IntegrationTestSuite) SetupSuite() { // IsCollateralRatioValid behavior testted in x/stablecoin/abci_test.go stableGen.Params.IsCollateralRatioValid = true - stableGen.ModuleAccountBalance = sdk.NewCoin(common.CollDenom, sdk.NewInt(10000000000)) + stableGen.ModuleAccountBalance = sdk.NewCoin(common.DenomColl, sdk.NewInt(10000000000)) stableGenJson := s.cfg.Codec.MustMarshalJSON(stableGen) genesisState[stabletypes.ModuleName] = stableGenJson @@ -99,7 +96,7 @@ func (s *IntegrationTestSuite) SetupSuite() { s.cfg.GenesisState = genesisState - s.network = testutilcli.New(s.T(), s.cfg) + s.network = testutilcli.NewNetwork(s.T(), s.cfg) _, err := s.network.WaitForHeight(1) s.Require().NoError(err) @@ -141,8 +138,8 @@ func (s IntegrationTestSuite) TestMintStableCmd() { minterAddr, sdk.NewCoins( sdk.NewInt64Coin(s.cfg.BondDenom, 20_000), - sdk.NewInt64Coin(common.GovDenom, 100_000_000), - sdk.NewInt64Coin(common.CollDenom, 100_000_000), + sdk.NewInt64Coin(common.DenomGov, 100_000_000), + sdk.NewInt64Coin(common.DenomColl, 100_000_000), ), val) @@ -201,7 +198,7 @@ func (s IntegrationTestSuite) TestMintStableCmd() { s.Require().NoError(err) s.Require().Equal( - balRes.Balances.AmountOf(common.StableDenom), tc.expectedStable) + balRes.Balances.AmountOf(common.DenomStable), tc.expectedStable) } }) } @@ -218,7 +215,7 @@ func (s IntegrationTestSuite) TestBurnStableCmd() { minterAddr, sdk.NewCoins( sdk.NewInt64Coin(s.cfg.BondDenom, 20000), - sdk.NewInt64Coin(common.StableDenom, 50_000_000), + sdk.NewInt64Coin(common.DenomStable, 50_000_000), ), val, ) @@ -256,8 +253,8 @@ func (s IntegrationTestSuite) TestBurnStableCmd() { expectedStable: sdk.ZeroInt(), expectedColl: sdk.NewInt(50_000_000 - 100_000), // Collateral minus 0,02% fees expectedGov: sdk.ZeroInt(), - expectedTreasury: sdk.NewCoins(sdk.NewInt64Coin(common.CollDenom, 50_000)), - expectedEf: sdk.NewCoins(sdk.NewInt64Coin(common.CollDenom, 50_000)), + expectedTreasury: sdk.NewCoins(sdk.NewInt64Coin(common.DenomColl, 50_000)), + expectedEf: sdk.NewCoins(sdk.NewInt64Coin(common.DenomColl, 50_000)), expectErr: false, respType: &sdk.TxResponse{}, expectedCode: 0, @@ -306,11 +303,11 @@ func (s IntegrationTestSuite) TestBurnStableCmd() { s.Require().NoError(err) s.Require().Equal( - tc.expectedColl, balRes.Balances.AmountOf(common.CollDenom)) + tc.expectedColl, balRes.Balances.AmountOf(common.DenomColl)) s.Require().Equal( - tc.expectedGov, balRes.Balances.AmountOf(common.GovDenom)) + tc.expectedGov, balRes.Balances.AmountOf(common.DenomGov)) s.Require().Equal( - tc.expectedStable, balRes.Balances.AmountOf(common.StableDenom)) + tc.expectedStable, balRes.Balances.AmountOf(common.DenomStable)) // Query treasury pool balance resp, err = banktestutil.QueryBalancesExec( diff --git a/x/stablecoin/genesis.go b/x/stablecoin/genesis.go index 5b4ac4e3a..1984fcd81 100644 --- a/x/stablecoin/genesis.go +++ b/x/stablecoin/genesis.go @@ -10,8 +10,6 @@ import ( // InitGenesis initializes the capability module's state from a provided genesis // state. func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState) { - // this line is used by starport scaffolding # genesis/module/init - if genState.ModuleAccountBalance.Amount.GT(sdk.ZeroInt()) { if err := k.BankKeeper.MintCoins(ctx, types.ModuleName, sdk.NewCoins(genState.ModuleAccountBalance)); err != nil { panic(err) diff --git a/x/stablecoin/genesis_test.go b/x/stablecoin/genesis_test.go index 1699da6f7..460796edd 100644 --- a/x/stablecoin/genesis_test.go +++ b/x/stablecoin/genesis_test.go @@ -9,17 +9,17 @@ import ( "github.com/NibiruChain/nibiru/x/common" "github.com/NibiruChain/nibiru/x/stablecoin" "github.com/NibiruChain/nibiru/x/stablecoin/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/nullify" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestGenesis(t *testing.T) { genesisState := types.GenesisState{ Params: types.DefaultParams(), - ModuleAccountBalance: sdk.NewCoin(common.CollDenom, sdk.ZeroInt()), + ModuleAccountBalance: sdk.NewCoin(common.DenomColl, sdk.ZeroInt()), } - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) k := nibiruApp.StablecoinKeeper stablecoin.InitGenesis(ctx, k, genesisState) got := stablecoin.ExportGenesis(ctx, k) diff --git a/x/stablecoin/keeper/collateral_ratio.go b/x/stablecoin/keeper/collateral_ratio.go index fe6734333..908309ce1 100644 --- a/x/stablecoin/keeper/collateral_ratio.go +++ b/x/stablecoin/keeper/collateral_ratio.go @@ -87,7 +87,7 @@ func (k *Keeper) EvaluateCollRatio(ctx sdk.Context) (err error) { // Should take TWAP price stablePrice, err := k.PricefeedKeeper.GetCurrentTWAPPrice( - ctx, common.StableDenom, common.CollDenom) + ctx, common.DenomStable, common.DenomColl) if err != nil { return err } @@ -114,14 +114,14 @@ func (k *Keeper) StableRequiredForTargetCollRatio( targetCollRatio := k.GetCollRatio(ctx) moduleAddr := k.AccountKeeper.GetModuleAddress(types.ModuleName) moduleCoins := k.BankKeeper.SpendableCoins(ctx, moduleAddr) - collDenoms := []string{common.CollDenom} + collDenoms := []string{common.DenomColl} currentTotalCollUSD := sdk.ZeroDec() for _, collDenom := range collDenoms { amtColl := moduleCoins.AmountOf(collDenom) priceColl, err := k.PricefeedKeeper.GetCurrentPrice( - ctx, collDenom, common.StableDenom) + ctx, collDenom, common.DenomStable) if err != nil { return sdk.ZeroDec(), err } @@ -139,7 +139,7 @@ func (k *Keeper) RecollateralizeCollAmtForTargetCollRatio( ) (neededCollAmount sdk.Int, err error) { neededUSDForRecoll, _ := k.StableRequiredForTargetCollRatio(ctx) priceCollStable, err := k.PricefeedKeeper.GetCurrentPrice( - ctx, common.CollDenom, common.StableDenom) + ctx, common.DenomColl, common.DenomStable) if err != nil { return sdk.Int{}, err } @@ -221,7 +221,7 @@ func (k Keeper) Recollateralize( // Compute GOV rewarded to user priceCollStable, err := k.PricefeedKeeper.GetCurrentPrice( - ctx, common.CollDenom, common.StableDenom) + ctx, common.DenomColl, common.DenomStable) if err != nil { return response, err } @@ -230,7 +230,7 @@ func (k Keeper) Recollateralize( if err != nil { return response, err } - outGov := sdk.NewCoin(common.GovDenom, outGovAmount) + outGov := sdk.NewCoin(common.DenomGov, outGovAmount) // Mint and send GOV reward from the module to the caller err = k.BankKeeper.MintCoins(ctx, types.ModuleName, sdk.NewCoins(outGov)) @@ -289,7 +289,7 @@ func (k *Keeper) GovAmtFromRecollateralize( bonusRate := params.GetBonusRateRecollAsDec() priceGovStable, err := k.PricefeedKeeper.GetCurrentPrice( - ctx, common.GovDenom, common.StableDenom) + ctx, common.DenomGov, common.DenomStable) if err != nil { return sdk.Int{}, err } @@ -329,7 +329,7 @@ func (k *Keeper) BuybackGovAmtForTargetCollRatio( neededUSDForRecoll, _ := k.StableRequiredForTargetCollRatio(ctx) neededUSDForBuyback := neededUSDForRecoll.Neg() priceGovStable, err := k.PricefeedKeeper.GetCurrentPrice( - ctx, common.GovDenom, common.StableDenom) + ctx, common.DenomGov, common.DenomStable) if err != nil { return sdk.Int{}, err } @@ -406,7 +406,7 @@ func (k Keeper) Buyback( // Compute USD (stable) value of the GOV sent by the caller: 'inUSD' priceGovStable, err := k.PricefeedKeeper.GetCurrentPrice( - ctx, common.GovDenom, common.StableDenom) + ctx, common.DenomGov, common.DenomStable) if err != nil { return response, err } @@ -417,7 +417,7 @@ func (k Keeper) Buyback( if err != nil { return response, err } - outColl := sdk.NewCoin(common.CollDenom, outCollAmount) + outColl := sdk.NewCoin(common.DenomColl, outCollAmount) // Send COLL from the module to the caller err = k.BankKeeper.SendCoinsFromModuleToAccount( @@ -463,7 +463,7 @@ func (k *Keeper) CollAmtFromBuyback( ctx sdk.Context, valUSD sdk.Dec, ) (collAmt sdk.Int, err error) { priceCollStable, err := k.PricefeedKeeper.GetCurrentPrice( - ctx, common.CollDenom, common.StableDenom) + ctx, common.DenomColl, common.DenomStable) if err != nil { return sdk.Int{}, err } diff --git a/x/stablecoin/keeper/collateral_ratio_test.go b/x/stablecoin/keeper/collateral_ratio_test.go index 03cae4437..311cdd6b1 100644 --- a/x/stablecoin/keeper/collateral_ratio_test.go +++ b/x/stablecoin/keeper/collateral_ratio_test.go @@ -6,11 +6,10 @@ import ( "time" "github.com/NibiruChain/nibiru/x/common" - pricefeedTypes "github.com/NibiruChain/nibiru/x/pricefeed/types" - ptypes "github.com/NibiruChain/nibiru/x/pricefeed/types" + pftypes "github.com/NibiruChain/nibiru/x/pricefeed/types" "github.com/NibiruChain/nibiru/x/stablecoin/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" @@ -28,7 +27,7 @@ func TestSetCollRatio_Input(t *testing.T) { executeTest := func(t *testing.T, testCase TestCase) { tc := testCase t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stablecoinKeeper := &nibiruApp.StablecoinKeeper err := stablecoinKeeper.SetCollRatio(ctx, tc.inCollRatio) @@ -77,22 +76,22 @@ func TestSetCollRatioUpdate(t *testing.T) { executeTest := func(t *testing.T, testCase TestCase) { tc := testCase t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stablecoinKeeper := &nibiruApp.StablecoinKeeper priceKeeper := &nibiruApp.PricefeedKeeper oracle := sample.AccAddress() - pairs := ptypes.NewParams([]ptypes.Pair{ - { - Token0: common.StableDenom, - Token1: common.CollDenom, - Oracles: []sdk.AccAddress{oracle}, - Active: true, - }, - }) + oracles := []sdk.AccAddress{oracle} + pair := common.AssetPair{ + Token0: common.DenomColl, + Token1: common.DenomStable, + } + params := pftypes.Params{ + Pairs: common.AssetPairs{pair}} - priceKeeper.SetParams(ctx, pairs) + priceKeeper.SetParams(ctx, params) + priceKeeper.WhitelistOracles(ctx, oracles) err := stablecoinKeeper.SetCollRatio(ctx, tc.inCollRatio) require.NoError(t, err) @@ -100,13 +99,12 @@ func TestSetCollRatioUpdate(t *testing.T) { _, err = priceKeeper.SetPrice( ctx, oracle, - /* token0 */ common.StableDenom, - /* token1 */ common.CollDenom, + /* pairStr */ pair.String(), /* price */ tc.price, /* expiry */ ctx.BlockTime().UTC().Add(time.Hour*1)) require.NoError(t, err) - err = priceKeeper.SetCurrentPrices(ctx, common.StableDenom, common.CollDenom) + err = priceKeeper.SetCurrentPrices(ctx, common.DenomColl, common.DenomStable) require.NoError(t, err) err = stablecoinKeeper.EvaluateCollRatio(ctx) @@ -124,10 +122,10 @@ func TestSetCollRatioUpdate(t *testing.T) { testCases := []TestCase{ { - name: "Price is higher than peg", + name: "Collateral price is higher than stable", inCollRatio: sdk.MustNewDecFromStr("0.8"), price: sdk.MustNewDecFromStr("1.1"), - expectedCollRatio: sdk.MustNewDecFromStr("0.7975"), + expectedCollRatio: sdk.MustNewDecFromStr("0.8025"), expectedPass: true, }, { @@ -145,10 +143,10 @@ func TestSetCollRatioUpdate(t *testing.T) { expectedPass: true, }, { - name: "Price is lower than peg", + name: "Collateral price is lower than stable", inCollRatio: sdk.MustNewDecFromStr("0.8"), price: sdk.MustNewDecFromStr("0.9"), - expectedCollRatio: sdk.MustNewDecFromStr("0.8025"), + expectedCollRatio: sdk.MustNewDecFromStr("0.7975"), expectedPass: true, }, } @@ -160,7 +158,7 @@ func TestSetCollRatioUpdate(t *testing.T) { func TestGetCollRatio_Input(t *testing.T) { testName := "GetCollRatio after setting default params returns expected value" t.Run(testName, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stablecoinKeeper := &nibiruApp.StablecoinKeeper stablecoinKeeper.SetParams(ctx, types.DefaultParams()) @@ -173,7 +171,7 @@ func TestGetCollRatio_Input(t *testing.T) { testName = "Setting to non-default value returns expected value" t.Run(testName, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stablecoinKeeper := &nibiruApp.StablecoinKeeper expectedCollRatio := sdk.MustNewDecFromStr("0.5") @@ -203,7 +201,7 @@ func TestStableRequiredForTargetCollRatio(t *testing.T) { protocolColl: sdk.NewInt(500), priceCollStable: sdk.OneDec(), // startCollUSD = 500 * 1 -> 500 postedAssetPairs: []common.AssetPair{ - common.CollStablePool, + common.PairCollStable, }, stableSupply: sdk.NewInt(1000), targetCollRatio: sdk.MustNewDecFromStr("0.6"), // 0.6 * 1000 = 600 @@ -214,7 +212,7 @@ func TestStableRequiredForTargetCollRatio(t *testing.T) { protocolColl: sdk.NewInt(600), priceCollStable: sdk.OneDec(), // startCollUSD = 600 * 1 = 600 postedAssetPairs: []common.AssetPair{ - common.CollStablePool, + common.PairCollStable, }, stableSupply: sdk.NewInt(1000), targetCollRatio: sdk.MustNewDecFromStr("0.5"), // 0.5 * 1000 = 500 @@ -235,37 +233,35 @@ func TestStableRequiredForTargetCollRatio(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stablecoinKeeper := &nibiruApp.StablecoinKeeper require.NoError(t, stablecoinKeeper.SetCollRatio(ctx, tc.targetCollRatio)) require.NoError(t, nibiruApp.BankKeeper.MintCoins( ctx, types.ModuleName, sdk.NewCoins( - sdk.NewCoin(common.CollDenom, tc.protocolColl), - sdk.NewCoin(common.StableDenom, tc.stableSupply), + sdk.NewCoin(common.DenomColl, tc.protocolColl), + sdk.NewCoin(common.DenomStable, tc.stableSupply), ), )) // Set up markets for the pricefeed keeper. oracle := sample.AccAddress() + oracles := []sdk.AccAddress{oracle} priceExpiry := ctx.BlockTime().Add(time.Hour) - pricefeedParams := pricefeedTypes.Params{ - Pairs: []pricefeedTypes.Pair{ - {Token0: common.CollDenom, - Token1: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - {Token0: common.GovDenom, - Token1: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }} + pairs := common.AssetPairs{ + {Token0: common.DenomColl, Token1: common.DenomStable}, + {Token0: common.DenomGov, Token1: common.DenomStable}, + } + pricefeedParams := pftypes.Params{Pairs: pairs} nibiruApp.PricefeedKeeper.SetParams(ctx, pricefeedParams) + nibiruApp.PricefeedKeeper.WhitelistOracles(ctx, oracles) // Post prices to each specified market with the oracle. prices := map[common.AssetPair]sdk.Dec{ - common.CollStablePool: tc.priceCollStable, + common.PairCollStable: tc.priceCollStable, } for _, pair := range tc.postedAssetPairs { _, err := nibiruApp.PricefeedKeeper.SetPrice( - ctx, oracle, pair.Token0, pair.Token1, prices[pair], priceExpiry) + ctx, oracle, pair.String(), prices[pair], priceExpiry) require.NoError(t, err) // Update the 'CurrentPrice' posted by the oracles. @@ -329,37 +325,36 @@ func TestRecollateralizeCollAmtForTargetCollRatio(t *testing.T) { for _, testCase := range expectedPasses { tc := testCase t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stablecoinKeeper := &nibiruApp.StablecoinKeeper require.NoError(t, stablecoinKeeper.SetCollRatio(ctx, tc.targetCollRatio)) require.NoError(t, nibiruApp.BankKeeper.MintCoins( ctx, types.ModuleName, sdk.NewCoins( - sdk.NewCoin(common.CollDenom, tc.protocolColl), - sdk.NewCoin(common.StableDenom, tc.stableSupply), + sdk.NewCoin(common.DenomColl, tc.protocolColl), + sdk.NewCoin(common.DenomStable, tc.stableSupply), ), )) // Set up markets for the pricefeed keeper. - pair := common.CollStablePool + pair := common.PairCollStable oracle := sample.AccAddress() priceExpiry := ctx.BlockTime().Add(time.Hour) - pricefeedParams := pricefeedTypes.Params{ - Pairs: []pricefeedTypes.Pair{ - {Token1: common.CollDenom, - Token0: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }} + pricefeedParams := pftypes.Params{ + Pairs: common.AssetPairs{pair}, + } nibiruApp.PricefeedKeeper.SetParams(ctx, pricefeedParams) + nibiruApp.PricefeedKeeper.OraclesStore().AddOracles( + ctx, pair, []sdk.AccAddress{oracle}) // Post prices to each market with the oracle. _, err := nibiruApp.PricefeedKeeper.SetPrice( - ctx, oracle, pair.Token0, pair.Token1, tc.priceCollStable, priceExpiry) + ctx, oracle, pair.String(), tc.priceCollStable, priceExpiry) require.NoError(t, err) // Update the 'CurrentPrice' posted by the oracles. for _, pfPair := range pricefeedParams.Pairs { err = nibiruApp.PricefeedKeeper.SetCurrentPrices(ctx, pfPair.Token0, pfPair.Token1) - require.NoError(t, err, "Error posting price for market: %d", pfPair.AsString()) + require.NoError(t, err, "Error posting price for market: %d", pfPair.String()) } neededCollAmount, err := stablecoinKeeper.RecollateralizeCollAmtForTargetCollRatio(ctx) @@ -387,25 +382,25 @@ func TestRecollateralizeCollAmtForTargetCollRatio(t *testing.T) { for _, testCase := range expectedFails { tc := testCase t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stablecoinKeeper := &nibiruApp.StablecoinKeeper require.NoError(t, stablecoinKeeper.SetCollRatio(ctx, tc.targetCollRatio)) require.NoError(t, nibiruApp.BankKeeper.MintCoins( ctx, types.ModuleName, sdk.NewCoins( - sdk.NewCoin(common.CollDenom, tc.protocolColl), - sdk.NewCoin(common.StableDenom, tc.stableSupply), + sdk.NewCoin(common.DenomColl, tc.protocolColl), + sdk.NewCoin(common.DenomStable, tc.stableSupply), ), )) // Set up markets for the pricefeed keeper. oracle := sample.AccAddress() - pricefeedParams := pricefeedTypes.Params{ - Pairs: []pricefeedTypes.Pair{ - {Token1: common.CollDenom, - Token0: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }} + pair := common.AssetPair{ + Token0: common.DenomStable, + Token1: common.DenomColl} + pricefeedParams := pftypes.Params{ + Pairs: common.AssetPairs{pair}} nibiruApp.PricefeedKeeper.SetParams(ctx, pricefeedParams) + nibiruApp.PricefeedKeeper.WhitelistOracles(ctx, []sdk.AccAddress{oracle}) neededCollAmount, err := stablecoinKeeper.RecollateralizeCollAmtForTargetCollRatio(ctx) if tc.expectedPass { @@ -447,7 +442,7 @@ func TestGovAmtFromFullRecollateralize(t *testing.T) { targetCollRatio: sdk.MustNewDecFromStr("0.6"), // 0.6 * 1000 = 600 priceCollStable: sdk.OneDec(), postedAssetPairs: []common.AssetPair{ - common.CollStablePool}, + common.PairCollStable}, govOut: sdk.Int{}, expectedPass: false, }, @@ -458,7 +453,7 @@ func TestGovAmtFromFullRecollateralize(t *testing.T) { targetCollRatio: sdk.MustNewDecFromStr("0.6"), // 0.6 * 1000 = 600 priceGovStable: sdk.OneDec(), postedAssetPairs: []common.AssetPair{ - common.GovStablePool}, + common.PairGovStable}, govOut: sdk.Int{}, expectedPass: false, }, @@ -468,8 +463,8 @@ func TestGovAmtFromFullRecollateralize(t *testing.T) { stableSupply: sdk.NewInt(10_000), targetCollRatio: sdk.MustNewDecFromStr("0.7"), // 0.7 * 10_000 = 7_000 postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, priceCollStable: sdk.OneDec(), priceGovStable: sdk.NewDec(2), @@ -484,8 +479,8 @@ func TestGovAmtFromFullRecollateralize(t *testing.T) { stableSupply: sdk.NewInt(100_000), targetCollRatio: sdk.MustNewDecFromStr("0.7"), // 0.7 * 100_000 = 70_000 postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, priceCollStable: sdk.OneDec(), priceGovStable: sdk.NewDec(10), @@ -500,8 +495,8 @@ func TestGovAmtFromFullRecollateralize(t *testing.T) { stableSupply: sdk.NewInt(100_000), targetCollRatio: sdk.MustNewDecFromStr("0.5"), // 0.5 * 100_000 = 50_000 postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, priceCollStable: sdk.OneDec(), priceGovStable: sdk.NewDec(10), @@ -515,37 +510,35 @@ func TestGovAmtFromFullRecollateralize(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stablecoinKeeper := &nibiruApp.StablecoinKeeper require.NoError(t, stablecoinKeeper.SetCollRatio(ctx, tc.targetCollRatio)) require.NoError(t, nibiruApp.BankKeeper.MintCoins( ctx, types.ModuleName, sdk.NewCoins( - sdk.NewCoin(common.CollDenom, tc.protocolColl), - sdk.NewCoin(common.StableDenom, tc.stableSupply), + sdk.NewCoin(common.DenomColl, tc.protocolColl), + sdk.NewCoin(common.DenomStable, tc.stableSupply), ), )) // Set up markets for the pricefeed keeper. oracle := sample.AccAddress() priceExpiry := ctx.BlockTime().Add(time.Hour) - pricefeedParams := pricefeedTypes.Params{ - Pairs: []pricefeedTypes.Pair{ - {Token1: common.CollDenom, - Token0: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - {Token1: common.GovDenom, - Token0: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }} + oracles := []sdk.AccAddress{oracle} + pairs := common.AssetPairs{ + common.PairCollStable, + common.PairGovStable, + } + pricefeedParams := pftypes.Params{Pairs: pairs} nibiruApp.PricefeedKeeper.SetParams(ctx, pricefeedParams) + nibiruApp.PricefeedKeeper.WhitelistOracles(ctx, oracles) prices := map[common.AssetPair]sdk.Dec{ - common.GovStablePool: tc.priceGovStable, - common.CollStablePool: tc.priceCollStable, + common.PairGovStable: tc.priceGovStable, + common.PairCollStable: tc.priceCollStable, } for _, pair := range tc.postedAssetPairs { _, err := nibiruApp.PricefeedKeeper.SetPrice( - ctx, oracle, pair.Token0, pair.Token1, prices[pair], priceExpiry) + ctx, oracle, pair.String(), prices[pair], priceExpiry) require.NoError(t, err) // Update the 'CurrentPrice' posted by the oracles. @@ -555,12 +548,12 @@ func TestGovAmtFromFullRecollateralize(t *testing.T) { // Post prices to each specified market with the oracle. prices = map[common.AssetPair]sdk.Dec{ - common.CollStablePool: tc.priceCollStable, - common.GovStablePool: tc.priceGovStable, + common.PairCollStable: tc.priceCollStable, + common.PairGovStable: tc.priceGovStable, } for _, assetPair := range tc.postedAssetPairs { _, err := nibiruApp.PricefeedKeeper.SetPrice( - ctx, oracle, assetPair.Token0, assetPair.Token1, + ctx, oracle, assetPair.String(), prices[assetPair], priceExpiry) require.NoError(t, err) @@ -617,8 +610,8 @@ func TestRecollateralize(t *testing.T) { { name: "both prices are $1", postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, scenario: NeededCollScenario{ protocolColl: sdk.NewInt(500_000), @@ -629,13 +622,13 @@ func TestRecollateralize(t *testing.T) { }, priceGovStable: sdk.OneDec(), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.CollDenom, 1_000_000_000), + sdk.NewInt64Coin(common.DenomColl, 1_000_000_000), ), expectedNeededUSD: sdk.NewDec(100_000), msg: types.MsgRecollateralize{ Creator: sample.AccAddress().String(), - Coll: sdk.NewCoin(common.CollDenom, sdk.NewInt(100_000)), + Coll: sdk.NewCoin(common.DenomColl, sdk.NewInt(100_000)), }, response: &types.MsgRecollateralizeResponse{ /* @@ -643,15 +636,15 @@ func TestRecollateralize(t *testing.T) { = 100_000 * (1.002) / priceGovStable = 100_200 / priceGovStable */ - Gov: sdk.NewCoin(common.GovDenom, sdk.NewInt(100_200)), + Gov: sdk.NewCoin(common.DenomGov, sdk.NewInt(100_200)), }, expectedPass: true, }, { name: "arbitrary valid prices", postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, scenario: NeededCollScenario{ protocolColl: sdk.NewInt(500_000), @@ -662,13 +655,13 @@ func TestRecollateralize(t *testing.T) { }, priceGovStable: sdk.NewDec(5), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.CollDenom, 1_000_000_000), + sdk.NewInt64Coin(common.DenomColl, 1_000_000_000), ), expectedNeededUSD: sdk.MustNewDecFromStr("150000.5"), msg: types.MsgRecollateralize{ Creator: sample.AccAddress().String(), - Coll: sdk.NewCoin(common.CollDenom, sdk.NewInt(50_000)), + Coll: sdk.NewCoin(common.DenomColl, sdk.NewInt(50_000)), }, response: &types.MsgRecollateralizeResponse{ /* @@ -678,15 +671,15 @@ func TestRecollateralize(t *testing.T) { = 55109.9499 / priceGovStable = 11021.98998 -> 11_021 */ - Gov: sdk.NewCoin(common.GovDenom, sdk.NewInt(11_021)), + Gov: sdk.NewCoin(common.DenomGov, sdk.NewInt(11_021)), }, expectedPass: true, }, { name: "protocol has sufficient collateral - error", postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, priceGovStable: sdk.NewDec(1), scenario: NeededCollScenario{ @@ -698,13 +691,13 @@ func TestRecollateralize(t *testing.T) { }, expectedNeededUSD: sdk.MustNewDecFromStr("-49.9995"), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.CollDenom, 1_000_000), + sdk.NewInt64Coin(common.DenomColl, 1_000_000), ), // Since 'neededUSD' is msg: types.MsgRecollateralize{ Creator: sample.AccAddress().String(), - Coll: sdk.NewCoin(common.CollDenom, sdk.NewInt(100)), + Coll: sdk.NewCoin(common.DenomColl, sdk.NewInt(100)), }, expectedPass: false, err: fmt.Errorf("protocol has sufficient COLL"), @@ -712,8 +705,8 @@ func TestRecollateralize(t *testing.T) { { name: "caller is broke - error", postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, priceGovStable: sdk.NewDec(1), scenario: NeededCollScenario{ @@ -725,13 +718,13 @@ func TestRecollateralize(t *testing.T) { }, expectedNeededUSD: sdk.MustNewDecFromStr("150"), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.CollDenom, 99), + sdk.NewInt64Coin(common.DenomColl, 99), ), // Since 'neededUSD' is msg: types.MsgRecollateralize{ Creator: sample.AccAddress().String(), - Coll: sdk.NewCoin(common.CollDenom, sdk.NewInt(200)), + Coll: sdk.NewCoin(common.DenomColl, sdk.NewInt(200)), }, expectedPass: false, err: fmt.Errorf("Not enough balance"), @@ -739,8 +732,8 @@ func TestRecollateralize(t *testing.T) { { name: "negative msg.Coll.Amount - error", postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, priceGovStable: sdk.NewDec(1), scenario: NeededCollScenario{ @@ -752,20 +745,21 @@ func TestRecollateralize(t *testing.T) { }, expectedNeededUSD: sdk.MustNewDecFromStr("400"), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.CollDenom, 400), + sdk.NewInt64Coin(common.DenomColl, 400), ), msg: types.MsgRecollateralize{ Creator: sample.AccAddress().String(), - Coll: sdk.Coin{Denom: common.CollDenom, Amount: sdk.NewInt(-200)}, + Coll: sdk.Coin{Denom: common.DenomColl, Amount: sdk.NewInt(-200)}, }, expectedPass: false, - err: fmt.Errorf("collateral input, -200uust, must be positive"), + err: fmt.Errorf( + "collateral input, -200%v, must be positive", common.DenomColl), }, { name: "pricefeed prices are expired - error", postedAssetPairs: []common.AssetPair{ - common.CollStablePool, + common.PairCollStable, }, priceGovStable: sdk.NewDec(1), scenario: NeededCollScenario{ @@ -777,11 +771,11 @@ func TestRecollateralize(t *testing.T) { }, expectedNeededUSD: sdk.MustNewDecFromStr("400"), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.CollDenom, 400), + sdk.NewInt64Coin(common.DenomColl, 400), ), msg: types.MsgRecollateralize{ Creator: sample.AccAddress().String(), - Coll: sdk.NewInt64Coin(common.CollDenom, 400), + Coll: sdk.NewInt64Coin(common.DenomColl, 400), }, expectedPass: false, @@ -794,13 +788,13 @@ func TestRecollateralize(t *testing.T) { t.Run(tc.name, func(t *testing.T) { require.EqualValues(t, tc.expectedNeededUSD, tc.scenario.CalcNeededUSD()) - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stablecoinKeeper := &nibiruApp.StablecoinKeeper require.NoError(t, stablecoinKeeper.SetCollRatio(ctx, tc.scenario.collRatio)) require.NoError(t, nibiruApp.BankKeeper.MintCoins( ctx, types.ModuleName, sdk.NewCoins( - sdk.NewCoin(common.CollDenom, tc.scenario.protocolColl), - sdk.NewCoin(common.StableDenom, tc.scenario.stableSupply), + sdk.NewCoin(common.DenomColl, tc.scenario.protocolColl), + sdk.NewCoin(common.DenomStable, tc.scenario.stableSupply), ), )) // Fund account @@ -815,23 +809,23 @@ func TestRecollateralize(t *testing.T) { // Set up markets for the pricefeed keeper. oracle := sample.AccAddress() + oracles := []sdk.AccAddress{oracle} priceExpiry := ctx.BlockTime().Add(time.Hour) - pricefeedParams := pricefeedTypes.Params{ - Pairs: []pricefeedTypes.Pair{ - {Token0: common.CollDenom, Token1: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - {Token0: common.GovDenom, Token1: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }} + pairs := common.AssetPairs{ + {Token0: common.DenomColl, Token1: common.DenomStable}, + {Token0: common.DenomGov, Token1: common.DenomStable}, + } + pricefeedParams := pftypes.Params{Pairs: pairs} nibiruApp.PricefeedKeeper.SetParams(ctx, pricefeedParams) + nibiruApp.PricefeedKeeper.WhitelistOracles(ctx, oracles) prices := map[common.AssetPair]sdk.Dec{ - common.GovStablePool: tc.priceGovStable, - common.CollStablePool: tc.scenario.priceCollStable, + common.PairGovStable: tc.priceGovStable, + common.PairCollStable: tc.scenario.priceCollStable, } for _, pair := range tc.postedAssetPairs { _, err := nibiruApp.PricefeedKeeper.SetPrice( - ctx, oracle, pair.Token0, pair.Token1, prices[pair], priceExpiry) + ctx, oracle, pair.String(), prices[pair], priceExpiry) require.NoError(t, err) // Update the 'CurrentPrice' posted by the oracles. @@ -841,12 +835,12 @@ func TestRecollateralize(t *testing.T) { // Post prices to each specified market with the oracle. prices = map[common.AssetPair]sdk.Dec{ - common.CollStablePool: tc.scenario.priceCollStable, - common.GovStablePool: tc.priceGovStable, + common.PairCollStable: tc.scenario.priceCollStable, + common.PairGovStable: tc.priceGovStable, } for _, assetPair := range tc.postedAssetPairs { _, err := nibiruApp.PricefeedKeeper.SetPrice( - ctx, oracle, assetPair.Token0, assetPair.Token1, + ctx, oracle, assetPair.String(), prices[assetPair], priceExpiry) require.NoError(t, err) @@ -879,7 +873,7 @@ func TestRecollateralize_Short(t *testing.T) { { name: "invalid address - error", test: func() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) goCtx := sdk.WrapSDKContext(ctx) msg := &types.MsgRecollateralize{ @@ -892,12 +886,12 @@ func TestRecollateralize_Short(t *testing.T) { { name: "prices expired - error", test: func() { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) goCtx := sdk.WrapSDKContext(ctx) sender := sample.AccAddress() msg := &types.MsgRecollateralize{ Creator: sender.String(), - Coll: sdk.NewInt64Coin(common.CollDenom, 100), + Coll: sdk.NewInt64Coin(common.DenomColl, 100), } _, err := nibiruApp.StablecoinKeeper.Recollateralize(goCtx, msg) require.ErrorContains(t, err, "input prices are expired") @@ -937,7 +931,7 @@ func TestBuyback_MsgFormat(t *testing.T) { } { tc := testCase t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) msg := types.MsgBuyback{ Creator: tc.caller, Gov: tc.gov, @@ -974,8 +968,8 @@ func TestBuyback(t *testing.T) { { name: "both prices are $1", postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, scenario: NeededCollScenario{ protocolColl: sdk.NewInt(700_000), @@ -986,32 +980,32 @@ func TestBuyback(t *testing.T) { }, priceGovStable: sdk.OneDec(), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.GovDenom, 1_000_000), + sdk.NewInt64Coin(common.DenomGov, 1_000_000), ), expectedAccFundsAfter: sdk.NewCoins( - sdk.NewInt64Coin(common.GovDenom, 900_000), // accFunds - inGov.Amount - sdk.NewInt64Coin(common.CollDenom, 100_000), // response.Coll + sdk.NewInt64Coin(common.DenomGov, 900_000), // accFunds - inGov.Amount + sdk.NewInt64Coin(common.DenomColl, 100_000), // response.Coll ), expectedNeededUSD: sdk.NewDec(-100_000), msg: types.MsgBuyback{ Creator: sample.AccAddress().String(), - Gov: sdk.NewCoin(common.GovDenom, sdk.NewInt(100_000)), + Gov: sdk.NewCoin(common.DenomGov, sdk.NewInt(100_000)), }, response: &types.MsgBuybackResponse{ /* Coll.Amount = inUSD * / priceCollStable = 100_000 / priceCollStable */ - Coll: sdk.NewCoin(common.CollDenom, sdk.NewInt(100_000)), + Coll: sdk.NewCoin(common.DenomColl, sdk.NewInt(100_000)), }, expectedPass: true, }, { name: "arbitrary valid prices", postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, scenario: NeededCollScenario{ protocolColl: sdk.NewInt(850_000), @@ -1022,17 +1016,17 @@ func TestBuyback(t *testing.T) { }, priceGovStable: sdk.NewDec(5), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.GovDenom, 1_000_000), + sdk.NewInt64Coin(common.DenomGov, 1_000_000), ), expectedAccFundsAfter: sdk.NewCoins( - sdk.NewInt64Coin(common.GovDenom, 953_000), // accFunds - inGov.Amount - sdk.NewInt64Coin(common.CollDenom, 213_636), // response.Coll + sdk.NewInt64Coin(common.DenomGov, 953_000), // accFunds - inGov.Amount + sdk.NewInt64Coin(common.DenomColl, 213_636), // response.Coll ), expectedNeededUSD: sdk.MustNewDecFromStr("-234999.15"), msg: types.MsgBuyback{ Creator: sample.AccAddress().String(), - Gov: sdk.NewCoin(common.GovDenom, sdk.NewInt(50_000)), + Gov: sdk.NewCoin(common.DenomGov, sdk.NewInt(50_000)), }, response: &types.MsgBuybackResponse{ /* @@ -1044,15 +1038,15 @@ func TestBuyback(t *testing.T) { = 47000 * 5 / 1.099999 = 213636.55785141626 -> 213_636 */ - Coll: sdk.NewCoin(common.CollDenom, sdk.NewInt(213_636)), + Coll: sdk.NewCoin(common.DenomColl, sdk.NewInt(213_636)), }, expectedPass: true, }, { name: "msg has more NIBI than the protocol needs, only needed sent", postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, scenario: NeededCollScenario{ protocolColl: sdk.NewInt(700_000), @@ -1063,29 +1057,29 @@ func TestBuyback(t *testing.T) { }, priceGovStable: sdk.OneDec(), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.GovDenom, 1_000_000), + sdk.NewInt64Coin(common.DenomGov, 1_000_000), ), expectedAccFundsAfter: sdk.NewCoins( - sdk.NewInt64Coin(common.GovDenom, 900_000), // accFunds - inGov.Amount - sdk.NewInt64Coin(common.CollDenom, 100_000), // response.Coll + sdk.NewInt64Coin(common.DenomGov, 900_000), // accFunds - inGov.Amount + sdk.NewInt64Coin(common.DenomColl, 100_000), // response.Coll ), expectedNeededUSD: sdk.NewDec(-100_000), msg: types.MsgBuyback{ Creator: sample.AccAddress().String(), - Gov: sdk.NewCoin(common.GovDenom, sdk.NewInt(200_000)), + Gov: sdk.NewCoin(common.DenomGov, sdk.NewInt(200_000)), }, response: &types.MsgBuybackResponse{ // Coll.Amount = inUSD * / priceCollStable - Coll: sdk.NewCoin(common.CollDenom, sdk.NewInt(100_000)), + Coll: sdk.NewCoin(common.DenomColl, sdk.NewInt(100_000)), }, expectedPass: true, }, { name: "protocol under-collateralized, so buyback won't run", postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, scenario: NeededCollScenario{ protocolColl: sdk.NewInt(700_000), @@ -1096,13 +1090,13 @@ func TestBuyback(t *testing.T) { }, priceGovStable: sdk.OneDec(), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.GovDenom, 1_000_000_000), + sdk.NewInt64Coin(common.DenomGov, 1_000_000_000), ), expectedNeededUSD: sdk.NewDec(100_000), msg: types.MsgBuyback{ Creator: sample.AccAddress().String(), - Gov: sdk.NewCoin(common.GovDenom, sdk.NewInt(100_000)), + Gov: sdk.NewCoin(common.DenomGov, sdk.NewInt(100_000)), }, response: &types.MsgBuybackResponse{}, expectedPass: false, @@ -1110,8 +1104,8 @@ func TestBuyback(t *testing.T) { { name: "caller has insufficient funds", postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, scenario: NeededCollScenario{ protocolColl: sdk.NewInt(700_000), @@ -1122,13 +1116,13 @@ func TestBuyback(t *testing.T) { }, priceGovStable: sdk.OneDec(), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.GovDenom, 1), + sdk.NewInt64Coin(common.DenomGov, 1), ), expectedNeededUSD: sdk.NewDec(-100_000), msg: types.MsgBuyback{ Creator: sample.AccAddress().String(), - Gov: sdk.NewCoin(common.GovDenom, sdk.NewInt(100_000)), + Gov: sdk.NewCoin(common.DenomGov, sdk.NewInt(100_000)), }, response: &types.MsgBuybackResponse{}, expectedPass: false, @@ -1136,7 +1130,7 @@ func TestBuyback(t *testing.T) { { name: "fail: missing collateral price post", postedAssetPairs: []common.AssetPair{ - common.GovStablePool, + common.PairGovStable, }, scenario: NeededCollScenario{ protocolColl: sdk.NewInt(700_000), @@ -1147,13 +1141,13 @@ func TestBuyback(t *testing.T) { }, priceGovStable: sdk.OneDec(), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.GovDenom, 1_000_000_000), + sdk.NewInt64Coin(common.DenomGov, 1_000_000_000), ), expectedNeededUSD: sdk.NewDec(-100_000), msg: types.MsgBuyback{ Creator: sample.AccAddress().String(), - Gov: sdk.NewCoin(common.GovDenom, sdk.NewInt(100_000)), + Gov: sdk.NewCoin(common.DenomGov, sdk.NewInt(100_000)), }, response: &types.MsgBuybackResponse{}, expectedPass: false, @@ -1161,7 +1155,7 @@ func TestBuyback(t *testing.T) { { name: "fail: missing NIBI price post", postedAssetPairs: []common.AssetPair{ - common.CollStablePool, + common.PairCollStable, }, scenario: NeededCollScenario{ protocolColl: sdk.NewInt(700_000), @@ -1172,13 +1166,13 @@ func TestBuyback(t *testing.T) { }, priceGovStable: sdk.OneDec(), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.GovDenom, 1_000_000_000), + sdk.NewInt64Coin(common.DenomGov, 1_000_000_000), ), expectedNeededUSD: sdk.NewDec(-100_000), msg: types.MsgBuyback{ Creator: sample.AccAddress().String(), - Gov: sdk.NewCoin(common.GovDenom, sdk.NewInt(100_000)), + Gov: sdk.NewCoin(common.DenomGov, sdk.NewInt(100_000)), }, response: &types.MsgBuybackResponse{}, expectedPass: false, @@ -1190,15 +1184,15 @@ func TestBuyback(t *testing.T) { t.Run(tc.name, func(t *testing.T) { require.EqualValues(t, tc.expectedNeededUSD, tc.scenario.CalcNeededUSD()) - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stablecoinKeeper := &nibiruApp.StablecoinKeeper require.NoError(t, stablecoinKeeper.SetCollRatio(ctx, tc.scenario.collRatio)) // Fund module account based on scenario require.NoError(t, nibiruApp.BankKeeper.MintCoins( ctx, types.ModuleName, sdk.NewCoins( - sdk.NewCoin(common.CollDenom, tc.scenario.protocolColl), - sdk.NewCoin(common.StableDenom, tc.scenario.stableSupply), + sdk.NewCoin(common.DenomColl, tc.scenario.protocolColl), + sdk.NewCoin(common.DenomStable, tc.scenario.stableSupply), ), )) @@ -1215,22 +1209,21 @@ func TestBuyback(t *testing.T) { // Set up markets for the pricefeed keeper. oracle := sample.AccAddress() priceExpiry := ctx.BlockTime().Add(time.Hour) - pricefeedParams := pricefeedTypes.Params{ - Pairs: []pricefeedTypes.Pair{ - {Token0: common.CollDenom, Token1: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - {Token0: common.GovDenom, Token1: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }} + pairs := common.AssetPairs{ + {Token0: common.DenomColl, Token1: common.DenomStable}, + {Token0: common.DenomGov, Token1: common.DenomStable}, + } + pricefeedParams := pftypes.Params{Pairs: pairs} nibiruApp.PricefeedKeeper.SetParams(ctx, pricefeedParams) + nibiruApp.PricefeedKeeper.WhitelistOracles(ctx, []sdk.AccAddress{oracle}) prices := map[common.AssetPair]sdk.Dec{ - common.GovStablePool: tc.priceGovStable, - common.CollStablePool: tc.scenario.priceCollStable, + common.PairGovStable: tc.priceGovStable, + common.PairCollStable: tc.scenario.priceCollStable, } for _, pair := range tc.postedAssetPairs { _, err := nibiruApp.PricefeedKeeper.SetPrice( - ctx, oracle, pair.Token0, pair.Token1, prices[pair], priceExpiry) + ctx, oracle, pair.String(), prices[pair], priceExpiry) require.NoError(t, err) // Update the 'CurrentPrice' posted by the oracles. @@ -1241,7 +1234,7 @@ func TestBuyback(t *testing.T) { // Post prices to each specified market with the oracle. for _, assetPair := range tc.postedAssetPairs { _, err := nibiruApp.PricefeedKeeper.SetPrice( - ctx, oracle, assetPair.Token0, assetPair.Token1, + ctx, oracle, assetPair.String(), prices[assetPair], priceExpiry) require.NoError(t, err) @@ -1282,8 +1275,8 @@ func TestBuybackGovAmtForTargetCollRatio(t *testing.T) { { name: "both prices $1, correct amount out", postedAssetPairs: []common.AssetPair{ - common.GovStablePool, - common.CollStablePool, + common.PairGovStable, + common.PairCollStable, }, scenario: NeededCollScenario{ protocolColl: sdk.NewInt(700_000), @@ -1313,7 +1306,7 @@ func TestBuybackGovAmtForTargetCollRatio(t *testing.T) { { name: "both prices $1, only coll price posted", postedAssetPairs: []common.AssetPair{ - common.CollStablePool, + common.PairCollStable, }, scenario: NeededCollScenario{ protocolColl: sdk.NewInt(700_000), @@ -1331,35 +1324,34 @@ func TestBuybackGovAmtForTargetCollRatio(t *testing.T) { for _, testCase := range testCases { tc := testCase t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stablecoinKeeper := &nibiruApp.StablecoinKeeper require.NoError(t, stablecoinKeeper.SetCollRatio(ctx, tc.scenario.collRatio)) require.NoError(t, nibiruApp.BankKeeper.MintCoins( ctx, types.ModuleName, sdk.NewCoins( - sdk.NewCoin(common.CollDenom, tc.scenario.protocolColl), - sdk.NewCoin(common.StableDenom, tc.scenario.stableSupply), + sdk.NewCoin(common.DenomColl, tc.scenario.protocolColl), + sdk.NewCoin(common.DenomStable, tc.scenario.stableSupply), ), )) // Set up markets for the pricefeed keeper. oracle := sample.AccAddress() priceExpiry := ctx.BlockTime().Add(time.Hour) - pricefeedParams := pricefeedTypes.Params{ - Pairs: []pricefeedTypes.Pair{ - {Token0: common.CollDenom, Token1: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - {Token0: common.GovDenom, Token1: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }} + pairs := common.AssetPairs{ + {Token0: common.DenomColl, Token1: common.DenomStable}, + {Token0: common.DenomGov, Token1: common.DenomStable}, + } + pricefeedParams := pftypes.Params{Pairs: pairs} nibiruApp.PricefeedKeeper.SetParams(ctx, pricefeedParams) + nibiruApp.PricefeedKeeper.WhitelistOracles(ctx, []sdk.AccAddress{oracle}) prices := map[common.AssetPair]sdk.Dec{ - common.GovStablePool: tc.priceGovStable, - common.CollStablePool: tc.scenario.priceCollStable, + common.PairGovStable: tc.priceGovStable, + common.PairCollStable: tc.scenario.priceCollStable, } for _, pair := range tc.postedAssetPairs { _, err := nibiruApp.PricefeedKeeper.SetPrice( - ctx, oracle, pair.Token0, pair.Token1, prices[pair], priceExpiry) + ctx, oracle, pair.String(), prices[pair], priceExpiry) require.NoError(t, err) // Update the 'CurrentPrice' posted by the oracles. @@ -1370,7 +1362,7 @@ func TestBuybackGovAmtForTargetCollRatio(t *testing.T) { // Post prices to each specified market with the oracle. for _, assetPair := range tc.postedAssetPairs { _, err := nibiruApp.PricefeedKeeper.SetPrice( - ctx, oracle, assetPair.Token0, assetPair.Token1, + ctx, oracle, assetPair.String(), prices[assetPair], priceExpiry) require.NoError(t, err) diff --git a/x/stablecoin/keeper/grpc_query_test.go b/x/stablecoin/keeper/grpc_query_test.go index c8cbf6b3c..f65c328e5 100644 --- a/x/stablecoin/keeper/grpc_query_test.go +++ b/x/stablecoin/keeper/grpc_query_test.go @@ -7,11 +7,11 @@ import ( "github.com/stretchr/testify/require" "github.com/NibiruChain/nibiru/x/stablecoin/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestParamsQuery(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) keeper := &nibiruApp.StablecoinKeeper wctx := sdk.WrapSDKContext(ctx) params := types.DefaultParams() diff --git a/x/stablecoin/keeper/keeper.go b/x/stablecoin/keeper/keeper.go index 2681c0eb1..30fc2485f 100644 --- a/x/stablecoin/keeper/keeper.go +++ b/x/stablecoin/keeper/keeper.go @@ -67,7 +67,7 @@ func (k Keeper) Logger(ctx sdk.Context) log.Logger { // GetModuleAccountBalance gets the airdrop coin balance of module account. func (k Keeper) GetModuleAccountBalance(ctx sdk.Context) sdk.Coin { moduleAccAddr := k.AccountKeeper.GetModuleAddress(types.ModuleName) - return k.BankKeeper.GetBalance(ctx, moduleAccAddr, common.GovDenom) + return k.BankKeeper.GetBalance(ctx, moduleAccAddr, common.DenomGov) } // GetParams get all parameters as types.Params diff --git a/x/stablecoin/keeper/keeper_test.go b/x/stablecoin/keeper/keeper_test.go index acbbef6f4..87e58bb28 100644 --- a/x/stablecoin/keeper/keeper_test.go +++ b/x/stablecoin/keeper/keeper_test.go @@ -6,7 +6,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/NibiruChain/nibiru/x/stablecoin/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" "github.com/stretchr/testify/require" ) @@ -47,7 +47,7 @@ func TestGetAndSetParams(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stableKeeper := nibiruApp.StablecoinKeeper params := tc.requiredParams() @@ -60,7 +60,7 @@ func TestGetAndSetParams(t *testing.T) { func TestGetAndSetParams_Errors(t *testing.T) { t.Run("Calling Get without setting causes a panic", func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(false) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(false) stableKeeper := nibiruApp.StablecoinKeeper require.Panics( diff --git a/x/stablecoin/keeper/mint_burn_stable.go b/x/stablecoin/keeper/mint_burn_stable.go index 851e32988..5278f0b3b 100644 --- a/x/stablecoin/keeper/mint_burn_stable.go +++ b/x/stablecoin/keeper/mint_burn_stable.go @@ -93,16 +93,16 @@ func (k Keeper) calcNeededGovAndFees( ctx sdk.Context, stable sdk.Coin, govRatio sdk.Dec, feeRatio sdk.Dec, ) (sdk.Coin, sdk.Coin, error) { priceGov, err := k.PricefeedKeeper.GetCurrentPrice( - ctx, common.GovDenom, common.StableDenom) + ctx, common.DenomGov, common.DenomStable) if err != nil { return sdk.Coin{}, sdk.Coin{}, err } neededGovUSD := stable.Amount.ToDec().Mul(govRatio) neededGovAmt := neededGovUSD.Quo(priceGov.Price).TruncateInt() - neededGov := sdk.NewCoin(common.GovDenom, neededGovAmt) + neededGov := sdk.NewCoin(common.DenomGov, neededGovAmt) govFeeAmt := neededGovAmt.ToDec().Mul(feeRatio).RoundInt() - govFee := sdk.NewCoin(common.GovDenom, govFeeAmt) + govFee := sdk.NewCoin(common.DenomGov, govFeeAmt) return neededGov, govFee, nil } @@ -115,16 +115,16 @@ func (k Keeper) calcNeededCollateralAndFees( feeRatio sdk.Dec, ) (sdk.Coin, sdk.Coin, error) { priceColl, err := k.PricefeedKeeper.GetCurrentPrice( - ctx, common.CollDenom, common.StableDenom) + ctx, common.DenomColl, common.DenomStable) if err != nil { return sdk.Coin{}, sdk.Coin{}, err } neededCollUSD := stable.Amount.ToDec().Mul(collRatio) neededCollAmt := neededCollUSD.Quo(priceColl.Price).TruncateInt() - neededColl := sdk.NewCoin(common.CollDenom, neededCollAmt) + neededColl := sdk.NewCoin(common.DenomColl, neededCollAmt) collFeeAmt := neededCollAmt.ToDec().Mul(feeRatio).RoundInt() - collFee := sdk.NewCoin(common.CollDenom, collFeeAmt) + collFee := sdk.NewCoin(common.DenomColl, collFeeAmt) return neededColl, collFee, nil } @@ -252,7 +252,7 @@ func (k Keeper) splitAndSendFeesToEfAndTreasury( amountEf := c.Amount.ToDec().Mul(efFeeRatio).TruncateInt() amountTreasury := c.Amount.Sub(amountEf) - if c.Denom == common.GovDenom { + if c.Denom == common.DenomGov { stableCoins := sdk.NewCoins(sdk.NewCoin(c.Denom, amountEf)) err := k.BankKeeper.SendCoinsFromAccountToModule( ctx, account, types.StableEFModuleAccount, stableCoins) diff --git a/x/stablecoin/keeper/mint_burn_stable_test.go b/x/stablecoin/keeper/mint_burn_stable_test.go index 9e6ff7cfb..bfb23a0bd 100644 --- a/x/stablecoin/keeper/mint_burn_stable_test.go +++ b/x/stablecoin/keeper/mint_burn_stable_test.go @@ -8,8 +8,8 @@ import ( pricefeedTypes "github.com/NibiruChain/nibiru/x/pricefeed/types" "github.com/NibiruChain/nibiru/x/stablecoin/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" @@ -55,10 +55,10 @@ func TestMsgMint_ValidateBasic(t *testing.T) { } func TestMsgMintStableResponse_HappyPath(t *testing.T) { - accFundsGovAmount := sdk.NewCoin(common.GovDenom, sdk.NewInt(10_000)) - accFundsCollAmount := sdk.NewCoin(common.CollDenom, sdk.NewInt(900_000)) - neededGovFees := sdk.NewCoin(common.GovDenom, sdk.NewInt(20)) // 0.002 fee - neededCollFees := sdk.NewCoin(common.CollDenom, sdk.NewInt(1_800)) // 0.002 fee + accFundsGovAmount := sdk.NewCoin(common.DenomGov, sdk.NewInt(10_000)) + accFundsCollAmount := sdk.NewCoin(common.DenomColl, sdk.NewInt(900_000)) + neededGovFees := sdk.NewCoin(common.DenomGov, sdk.NewInt(20)) // 0.002 fee + neededCollFees := sdk.NewCoin(common.DenomColl, sdk.NewInt(1_800)) // 0.002 fee accFundsAmt := sdk.NewCoins( accFundsGovAmount.Add(neededGovFees), @@ -82,7 +82,7 @@ func TestMsgMintStableResponse_HappyPath(t *testing.T) { accFunds: accFundsAmt, msgMint: types.MsgMintStable{ Creator: sample.AccAddress().String(), - Stable: sdk.NewCoin(common.StableDenom, sdk.NewInt(1_000_000)), + Stable: sdk.NewCoin(common.DenomStable, sdk.NewInt(1_000_000)), }, govPrice: sdk.MustNewDecFromStr("10"), collPrice: sdk.MustNewDecFromStr("1"), @@ -94,18 +94,18 @@ func TestMsgMintStableResponse_HappyPath(t *testing.T) { accFunds: accFundsAmt, msgMint: types.MsgMintStable{ Creator: sample.AccAddress().String(), - Stable: sdk.NewCoin(common.StableDenom, sdk.NewInt(1_000_000)), + Stable: sdk.NewCoin(common.DenomStable, sdk.NewInt(1_000_000)), }, msgResponse: types.MsgMintStableResponse{ - Stable: sdk.NewCoin(common.StableDenom, sdk.NewInt(1_000_000)), + Stable: sdk.NewCoin(common.DenomStable, sdk.NewInt(1_000_000)), UsedCoins: sdk.NewCoins(accFundsCollAmount, accFundsGovAmount), FeesPayed: sdk.NewCoins(neededCollFees, neededGovFees), }, govPrice: sdk.MustNewDecFromStr("10"), collPrice: sdk.MustNewDecFromStr("1"), - supplyNIBI: sdk.NewCoin(common.GovDenom, sdk.NewInt(10)), + supplyNIBI: sdk.NewCoin(common.DenomGov, sdk.NewInt(10)), // 10_000 - 20 (neededAmt - fees) - 10 (0.5 of fees from EFund are burned) - supplyNUSD: sdk.NewCoin(common.StableDenom, sdk.NewInt(1_000_000)), + supplyNUSD: sdk.NewCoin(common.DenomStable, sdk.NewInt(1_000_000)), err: nil, isCollateralRatioValid: true, }, @@ -114,7 +114,7 @@ func TestMsgMintStableResponse_HappyPath(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) acc, _ := sdk.AccAddressFromBech32(tc.msgMint.Creator) oracle := sample.AccAddress() @@ -123,16 +123,13 @@ func TestMsgMintStableResponse_HappyPath(t *testing.T) { // Set up pairs for the pricefeed keeper. priceKeeper := &nibiruApp.PricefeedKeeper - pfParams := pricefeedTypes.Params{ - Pairs: []pricefeedTypes.Pair{ - {Token0: common.GovDenom, - Token1: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - {Token0: common.CollDenom, - Token1: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }} + pairs := common.AssetPairs{ + {Token0: common.DenomGov, Token1: common.DenomStable}, + {Token0: common.DenomColl, Token1: common.DenomStable}, + } + pfParams := pricefeedTypes.Params{Pairs: pairs} priceKeeper.SetParams(ctx, pfParams) + priceKeeper.WhitelistOracles(ctx, []sdk.AccAddress{oracle}) collRatio := sdk.MustNewDecFromStr("0.9") feeRatio := sdk.MustNewDecFromStr("0.002") @@ -159,11 +156,11 @@ func TestMsgMintStableResponse_HappyPath(t *testing.T) { // Post prices to each pair with the oracle. priceExpiry := ctx.BlockTime().Add(time.Hour) _, err := priceKeeper.SetPrice( - ctx, oracle, common.GovDenom, common.StableDenom, tc.govPrice, priceExpiry, + ctx, oracle, common.PairGovStable.String(), tc.govPrice, priceExpiry, ) require.NoError(t, err) _, err = priceKeeper.SetPrice( - ctx, oracle, common.CollDenom, common.StableDenom, tc.collPrice, priceExpiry, + ctx, oracle, common.PairCollStable.String(), tc.collPrice, priceExpiry, ) require.NoError(t, err) @@ -197,7 +194,7 @@ func TestMsgMintStableResponse_HappyPath(t *testing.T) { ctx, nibiruApp.AccountKeeper.GetModuleAddress(types.StableEFModuleAccount), ) collFeesInEf := neededCollFees.Amount.ToDec().Mul(sdk.MustNewDecFromStr("0.5")).TruncateInt() - assert.Equal(t, sdk.NewCoins(sdk.NewCoin(common.CollDenom, collFeesInEf)), efModuleBalance) + assert.Equal(t, sdk.NewCoins(sdk.NewCoin(common.DenomColl, collFeesInEf)), efModuleBalance) // Check balances in Treasury treasuryModuleBalance := nibiruApp.BankKeeper. @@ -207,8 +204,8 @@ func TestMsgMintStableResponse_HappyPath(t *testing.T) { assert.Equal( t, sdk.NewCoins( - sdk.NewCoin(common.CollDenom, collFeesInTreasury), - sdk.NewCoin(common.GovDenom, govFeesInTreasury), + sdk.NewCoin(common.DenomColl, collFeesInTreasury), + sdk.NewCoin(common.DenomGov, govFeesInTreasury), ), treasuryModuleBalance, ) @@ -229,77 +226,77 @@ func TestMsgMintStableResponse_NotEnoughFunds(t *testing.T) { { name: "User has no GOV", accFunds: sdk.NewCoins( - sdk.NewCoin(common.CollDenom, sdk.NewInt(9001)), - sdk.NewCoin(common.GovDenom, sdk.NewInt(0)), + sdk.NewCoin(common.DenomColl, sdk.NewInt(9001)), + sdk.NewCoin(common.DenomGov, sdk.NewInt(0)), ), msgMint: types.MsgMintStable{ Creator: sample.AccAddress().String(), - Stable: sdk.NewCoin(common.StableDenom, sdk.NewInt(100)), + Stable: sdk.NewCoin(common.DenomStable, sdk.NewInt(100)), }, msgResponse: types.MsgMintStableResponse{ - Stable: sdk.NewCoin(common.StableDenom, sdk.NewInt(0)), + Stable: sdk.NewCoin(common.DenomStable, sdk.NewInt(0)), }, govPrice: sdk.MustNewDecFromStr("10"), collPrice: sdk.MustNewDecFromStr("1"), - err: types.NotEnoughBalance.Wrap(common.GovDenom), + err: types.NotEnoughBalance.Wrap(common.DenomGov), }, { name: "User has no COLL", accFunds: sdk.NewCoins( - sdk.NewCoin(common.CollDenom, sdk.NewInt(0)), - sdk.NewCoin(common.GovDenom, sdk.NewInt(9001)), + sdk.NewCoin(common.DenomColl, sdk.NewInt(0)), + sdk.NewCoin(common.DenomGov, sdk.NewInt(9001)), ), msgMint: types.MsgMintStable{ Creator: sample.AccAddress().String(), - Stable: sdk.NewCoin(common.StableDenom, sdk.NewInt(100)), + Stable: sdk.NewCoin(common.DenomStable, sdk.NewInt(100)), }, msgResponse: types.MsgMintStableResponse{ - Stable: sdk.NewCoin(common.StableDenom, sdk.NewInt(0)), + Stable: sdk.NewCoin(common.DenomStable, sdk.NewInt(0)), }, govPrice: sdk.MustNewDecFromStr("10"), collPrice: sdk.MustNewDecFromStr("1"), - err: types.NotEnoughBalance.Wrap(common.CollDenom), + err: types.NotEnoughBalance.Wrap(common.DenomColl), }, { name: "Not enough GOV", accFunds: sdk.NewCoins( - sdk.NewCoin(common.CollDenom, sdk.NewInt(9001)), - sdk.NewCoin(common.GovDenom, sdk.NewInt(1)), + sdk.NewCoin(common.DenomColl, sdk.NewInt(9001)), + sdk.NewCoin(common.DenomGov, sdk.NewInt(1)), ), msgMint: types.MsgMintStable{ Creator: sample.AccAddress().String(), - Stable: sdk.NewCoin(common.StableDenom, sdk.NewInt(1000)), + Stable: sdk.NewCoin(common.DenomStable, sdk.NewInt(1000)), }, msgResponse: types.MsgMintStableResponse{ - Stable: sdk.NewCoin(common.StableDenom, sdk.NewInt(0)), + Stable: sdk.NewCoin(common.DenomStable, sdk.NewInt(0)), }, govPrice: sdk.MustNewDecFromStr("10"), collPrice: sdk.MustNewDecFromStr("1"), err: types.NotEnoughBalance.Wrap( - sdk.NewCoin(common.GovDenom, sdk.NewInt(1)).String()), + sdk.NewCoin(common.DenomGov, sdk.NewInt(1)).String()), }, { name: "Not enough COLL", accFunds: sdk.NewCoins( - sdk.NewCoin(common.CollDenom, sdk.NewInt(1)), - sdk.NewCoin(common.GovDenom, sdk.NewInt(9001)), + sdk.NewCoin(common.DenomColl, sdk.NewInt(1)), + sdk.NewCoin(common.DenomGov, sdk.NewInt(9001)), ), msgMint: types.MsgMintStable{ Creator: sample.AccAddress().String(), - Stable: sdk.NewCoin(common.StableDenom, sdk.NewInt(100)), + Stable: sdk.NewCoin(common.DenomStable, sdk.NewInt(100)), }, msgResponse: types.MsgMintStableResponse{ - Stable: sdk.NewCoin(common.StableDenom, sdk.NewInt(0)), + Stable: sdk.NewCoin(common.DenomStable, sdk.NewInt(0)), }, govPrice: sdk.MustNewDecFromStr("10"), collPrice: sdk.MustNewDecFromStr("1"), err: types.NotEnoughBalance.Wrap( - sdk.NewCoin(common.CollDenom, sdk.NewInt(1)).String()), + sdk.NewCoin(common.DenomColl, sdk.NewInt(1)).String()), }, } for _, testCase := range testCases { tc := testCase t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) acc, _ := sdk.AccAddressFromBech32(tc.msgMint.Creator) oracle := sample.AccAddress() @@ -308,18 +305,13 @@ func TestMsgMintStableResponse_NotEnoughFunds(t *testing.T) { // Set up pairs for the pricefeed keeper. priceKeeper := &nibiruApp.PricefeedKeeper - pfParams := pricefeedTypes.Params{ - Pairs: []pricefeedTypes.Pair{ - { - Token1: common.GovDenom, - Token0: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - { - Token1: common.CollDenom, - Token0: common.StableDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }} + pairs := common.AssetPairs{ + common.PairCollStable, + common.PairGovStable, + } + pfParams := pricefeedTypes.Params{Pairs: pairs} priceKeeper.SetParams(ctx, pfParams) + priceKeeper.WhitelistOracles(ctx, []sdk.AccAddress{oracle}) collRatio := sdk.MustNewDecFromStr("0.9") feeRatio := sdk.ZeroDec() @@ -343,21 +335,21 @@ func TestMsgMintStableResponse_NotEnoughFunds(t *testing.T) { ), ) - // Post prices to each pair with the oracle. + t.Log("Post prices to each pair with the oracle.") priceExpiry := ctx.BlockTime().Add(time.Hour) _, err := priceKeeper.SetPrice( - ctx, oracle, common.GovDenom, common.StableDenom, tc.govPrice, priceExpiry, + ctx, oracle, common.PairGovStable.String(), tc.govPrice, priceExpiry, ) require.NoError(t, err) _, err = priceKeeper.SetPrice( - ctx, oracle, common.CollDenom, common.StableDenom, tc.collPrice, priceExpiry, + ctx, oracle, common.PairCollStable.String(), tc.collPrice, priceExpiry, ) require.NoError(t, err) // Update the 'CurrentPrice' posted by the oracles. for _, pair := range pfParams.Pairs { err = priceKeeper.SetCurrentPrices(ctx, pair.Token0, pair.Token1) - require.NoError(t, err, "Error posting price for pair: %d", pair) + require.NoError(t, err, "Error posting price for pair: %d", pair.String()) } // Fund account @@ -433,14 +425,14 @@ func TestMsgBurnResponse_NotEnoughFunds(t *testing.T) { }{ { name: "Not enough stable", - accFunds: sdk.NewCoins(sdk.NewInt64Coin(common.StableDenom, 10)), + accFunds: sdk.NewCoins(sdk.NewInt64Coin(common.DenomStable, 10)), msgBurn: types.MsgBurnStable{ Creator: sample.AccAddress().String(), - Stable: sdk.NewInt64Coin(common.StableDenom, 9001), + Stable: sdk.NewInt64Coin(common.DenomStable, 9001), }, msgResponse: &types.MsgBurnStableResponse{ - Collateral: sdk.NewCoin(common.GovDenom, sdk.ZeroInt()), - Gov: sdk.NewCoin(common.CollDenom, sdk.ZeroInt()), + Collateral: sdk.NewCoin(common.DenomGov, sdk.ZeroInt()), + Gov: sdk.NewCoin(common.DenomColl, sdk.ZeroInt()), }, govPrice: sdk.MustNewDecFromStr("10"), collPrice: sdk.MustNewDecFromStr("1"), @@ -452,29 +444,29 @@ func TestMsgBurnResponse_NotEnoughFunds(t *testing.T) { govPrice: sdk.MustNewDecFromStr("10"), collPrice: sdk.MustNewDecFromStr("1"), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.StableDenom, 1000000000), + sdk.NewInt64Coin(common.DenomStable, 1000000000), ), moduleFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.CollDenom, 100000000), + sdk.NewInt64Coin(common.DenomColl, 100000000), ), msgBurn: types.MsgBurnStable{ Creator: sample.AccAddress().String(), - Stable: sdk.NewCoin(common.StableDenom, sdk.ZeroInt()), + Stable: sdk.NewCoin(common.DenomStable, sdk.ZeroInt()), }, msgResponse: &types.MsgBurnStableResponse{ - Gov: sdk.NewCoin(common.GovDenom, sdk.ZeroInt()), - Collateral: sdk.NewCoin(common.CollDenom, sdk.ZeroInt()), + Gov: sdk.NewCoin(common.DenomGov, sdk.ZeroInt()), + Collateral: sdk.NewCoin(common.DenomColl, sdk.ZeroInt()), FeesPayed: sdk.NewCoins(), }, expectedPass: true, - err: types.NoCoinFound.Wrap(common.StableDenom).Error(), + err: types.NoCoinFound.Wrap(common.DenomStable).Error(), }, } for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) acc, _ := sdk.AccAddressFromBech32(tc.msgBurn.Creator) oracle := sample.AccAddress() @@ -503,27 +495,26 @@ func TestMsgBurnResponse_NotEnoughFunds(t *testing.T) { // Set up pairs for the pricefeed keeper. priceKeeper := nibiruApp.PricefeedKeeper - pfParams := pricefeedTypes.Params{ - Pairs: []pricefeedTypes.Pair{ - {Token1: common.StableDenom, Token0: common.GovDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - {Token1: common.StableDenom, Token0: common.CollDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }} + pairs := common.AssetPairs{ + {Token1: common.DenomStable, Token0: common.DenomGov}, + {Token1: common.DenomStable, Token0: common.DenomColl}, + } + pfParams := pricefeedTypes.Params{Pairs: pairs} priceKeeper.SetParams(ctx, pfParams) + priceKeeper.WhitelistOracles(ctx, []sdk.AccAddress{oracle}) defaultParams := types.DefaultParams() defaultParams.IsCollateralRatioValid = true nibiruApp.StablecoinKeeper.SetParams(ctx, defaultParams) - // Post prices to each pair with the oracle. + t.Log("Post prices to each pair with the oracle.") priceExpiry := ctx.BlockTime().Add(time.Hour) _, err := priceKeeper.SetPrice( - ctx, oracle, common.GovDenom, common.StableDenom, tc.govPrice, priceExpiry, + ctx, oracle, common.PairGovStable.String(), tc.govPrice, priceExpiry, ) require.NoError(t, err) _, err = priceKeeper.SetPrice( - ctx, oracle, common.CollDenom, common.StableDenom, tc.collPrice, priceExpiry, + ctx, oracle, common.PairCollStable.String(), tc.collPrice, priceExpiry, ) require.NoError(t, err) @@ -581,17 +572,17 @@ func TestMsgBurnResponse_HappyPath(t *testing.T) { govPrice: sdk.MustNewDecFromStr("10"), collPrice: sdk.MustNewDecFromStr("1"), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.StableDenom, 1_000_000_000), + sdk.NewInt64Coin(common.DenomStable, 1_000_000_000), ), moduleFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.CollDenom, 100_000_000), + sdk.NewInt64Coin(common.DenomColl, 100_000_000), ), msgBurn: types.MsgBurnStable{ Creator: sample.AccAddress().String(), - Stable: sdk.NewInt64Coin(common.StableDenom, 10_000_000), + Stable: sdk.NewInt64Coin(common.DenomStable, 10_000_000), }, - ecosystemFund: sdk.NewCoins(sdk.NewInt64Coin(common.CollDenom, 9000)), - treasuryFund: sdk.NewCoins(sdk.NewInt64Coin(common.CollDenom, 9000), sdk.NewInt64Coin(common.GovDenom, 100)), + ecosystemFund: sdk.NewCoins(sdk.NewInt64Coin(common.DenomColl, 9000)), + treasuryFund: sdk.NewCoins(sdk.NewInt64Coin(common.DenomColl, 9000), sdk.NewInt64Coin(common.DenomGov, 100)), expectedPass: false, isCollateralRatioValid: false, err: types.NoValidCollateralRatio, @@ -601,27 +592,27 @@ func TestMsgBurnResponse_HappyPath(t *testing.T) { govPrice: sdk.MustNewDecFromStr("10"), collPrice: sdk.MustNewDecFromStr("1"), accFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.StableDenom, 1_000_000_000), + sdk.NewInt64Coin(common.DenomStable, 1_000_000_000), ), moduleFunds: sdk.NewCoins( - sdk.NewInt64Coin(common.CollDenom, 100_000_000), + sdk.NewInt64Coin(common.DenomColl, 100_000_000), ), msgBurn: types.MsgBurnStable{ Creator: sample.AccAddress().String(), - Stable: sdk.NewInt64Coin(common.StableDenom, 10_000_000), + Stable: sdk.NewInt64Coin(common.DenomStable, 10_000_000), }, msgResponse: types.MsgBurnStableResponse{ - Gov: sdk.NewInt64Coin(common.GovDenom, 100_000-200), // amount - fees 0,02% - Collateral: sdk.NewInt64Coin(common.CollDenom, 9_000_000-18_000), // amount - fees 0,02% + Gov: sdk.NewInt64Coin(common.DenomGov, 100_000-200), // amount - fees 0,02% + Collateral: sdk.NewInt64Coin(common.DenomColl, 9_000_000-18_000), // amount - fees 0,02% FeesPayed: sdk.NewCoins( - sdk.NewInt64Coin(common.GovDenom, 200), - sdk.NewInt64Coin(common.CollDenom, 18_000), + sdk.NewInt64Coin(common.DenomGov, 200), + sdk.NewInt64Coin(common.DenomColl, 18_000), ), }, - supplyNIBI: sdk.NewCoin(common.GovDenom, sdk.NewInt(100_000-100)), // nibiru minus 0.5 of fees burned (the part that goes to EF) - supplyNUSD: sdk.NewCoin(common.StableDenom, sdk.NewInt(1_000_000_000-10_000_000)), - ecosystemFund: sdk.NewCoins(sdk.NewInt64Coin(common.CollDenom, 9000)), - treasuryFund: sdk.NewCoins(sdk.NewInt64Coin(common.CollDenom, 9000), sdk.NewInt64Coin(common.GovDenom, 100)), + supplyNIBI: sdk.NewCoin(common.DenomGov, sdk.NewInt(100_000-100)), // nibiru minus 0.5 of fees burned (the part that goes to EF) + supplyNUSD: sdk.NewCoin(common.DenomStable, sdk.NewInt(1_000_000_000-10_000_000)), + ecosystemFund: sdk.NewCoins(sdk.NewInt64Coin(common.DenomColl, 9000)), + treasuryFund: sdk.NewCoins(sdk.NewInt64Coin(common.DenomColl, 9000), sdk.NewInt64Coin(common.DenomGov, 100)), expectedPass: true, isCollateralRatioValid: true, }, @@ -630,7 +621,7 @@ func TestMsgBurnResponse_HappyPath(t *testing.T) { for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) acc, _ := sdk.AccAddressFromBech32(tc.msgBurn.Creator) oracle := sample.AccAddress() @@ -659,30 +650,29 @@ func TestMsgBurnResponse_HappyPath(t *testing.T) { // Set up pairs for the pricefeed keeper. priceKeeper := nibiruApp.PricefeedKeeper - pfParams := pricefeedTypes.Params{ - Pairs: []pricefeedTypes.Pair{ - {Token1: common.StableDenom, Token0: common.GovDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - {Token1: common.StableDenom, Token0: common.CollDenom, - Oracles: []sdk.AccAddress{oracle}, Active: true}, - }} + pairs := common.AssetPairs{ + {Token0: common.DenomGov, Token1: common.DenomStable}, + {Token0: common.DenomColl, Token1: common.DenomStable}, + } + pfParams := pricefeedTypes.Params{Pairs: pairs} priceKeeper.SetParams(ctx, pfParams) + priceKeeper.WhitelistOracles(ctx, []sdk.AccAddress{oracle}) - // Post prices to each pair with the oracle. + t.Log("Post prices to each pair with the oracle.") priceExpiry := ctx.BlockTime().Add(time.Hour) _, err := priceKeeper.SetPrice( - ctx, oracle, common.GovDenom, common.StableDenom, tc.govPrice, priceExpiry, + ctx, oracle, common.PairGovStable.String(), tc.govPrice, priceExpiry, ) require.NoError(t, err) _, err = priceKeeper.SetPrice( - ctx, oracle, common.CollDenom, common.StableDenom, tc.collPrice, priceExpiry, + ctx, oracle, common.PairCollStable.String(), tc.collPrice, priceExpiry, ) require.NoError(t, err) // Update the 'CurrentPrice' posted by the oracles. for _, pair := range pfParams.Pairs { err = priceKeeper.SetCurrentPrices(ctx, pair.Token0, pair.Token1) - require.NoError(t, err, "Error posting price for pair: %d", pair) + require.NoError(t, err, "Error posting price for pair: %d", pair.String()) } // Add collaterals to the module diff --git a/x/stablecoin/keeper/msg_server_test.go b/x/stablecoin/keeper/msg_server_test.go index 1b7abf0bd..24e6c9d11 100644 --- a/x/stablecoin/keeper/msg_server_test.go +++ b/x/stablecoin/keeper/msg_server_test.go @@ -4,7 +4,7 @@ import ( "testing" sckeeper "github.com/NibiruChain/nibiru/x/stablecoin/keeper" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" "github.com/stretchr/testify/require" ) @@ -23,7 +23,7 @@ func TestNewMsgServerImpl(t *testing.T) { }) } - nibiruApp, _ := testutilapp.NewNibiruApp(true) + nibiruApp, _ := testapp.NewNibiruAppAndContext(true) testCases := []TestCase{ { name: "Default NibiruApp.StablecoinKeeper, should pass", diff --git a/x/stablecoin/keeper/params_test.go b/x/stablecoin/keeper/params_test.go index affe63b9d..4acf0868f 100644 --- a/x/stablecoin/keeper/params_test.go +++ b/x/stablecoin/keeper/params_test.go @@ -8,11 +8,11 @@ import ( "github.com/stretchr/testify/require" "github.com/NibiruChain/nibiru/x/stablecoin/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestGetParams(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) stableKeeper := &nibiruApp.StablecoinKeeper params := types.DefaultParams() diff --git a/x/stablecoin/keeper/supply.go b/x/stablecoin/keeper/supply.go index f9d9b7430..65bb38991 100644 --- a/x/stablecoin/keeper/supply.go +++ b/x/stablecoin/keeper/supply.go @@ -13,13 +13,13 @@ var LiquidityRatioBands = sdk.MustNewDecFromStr("0.001") func (k Keeper) GetSupplyNUSD( ctx sdk.Context, ) sdk.Coin { - return k.BankKeeper.GetSupply(ctx, common.StableDenom) + return k.BankKeeper.GetSupply(ctx, common.DenomStable) } func (k Keeper) GetSupplyNIBI( ctx sdk.Context, ) sdk.Coin { - return k.BankKeeper.GetSupply(ctx, common.GovDenom) + return k.BankKeeper.GetSupply(ctx, common.DenomGov) } func (k Keeper) GetStableMarketCap(ctx sdk.Context) sdk.Int { @@ -27,7 +27,7 @@ func (k Keeper) GetStableMarketCap(ctx sdk.Context) sdk.Int { } func (k Keeper) GetGovMarketCap(ctx sdk.Context) (sdk.Int, error) { - pairID, err := k.DexKeeper.GetFromPair(ctx, common.GovDenom, common.StableDenom) + pairID, err := k.DexKeeper.GetFromPair(ctx, common.DenomGov, common.DenomStable) if err != nil { return sdk.Int{}, err } @@ -37,7 +37,7 @@ func (k Keeper) GetGovMarketCap(ctx sdk.Context) (sdk.Int, error) { return sdk.Int{}, err } - price, err := pool.CalcSpotPrice(common.GovDenom, common.StableDenom) + price, err := pool.CalcSpotPrice(common.DenomGov, common.DenomStable) if err != nil { return sdk.Int{}, err } diff --git a/x/stablecoin/keeper/supply_test.go b/x/stablecoin/keeper/supply_test.go index 8405f2dbf..6366c8fa2 100644 --- a/x/stablecoin/keeper/supply_test.go +++ b/x/stablecoin/keeper/supply_test.go @@ -10,17 +10,17 @@ import ( dextypes "github.com/NibiruChain/nibiru/x/dex/types" "github.com/NibiruChain/nibiru/x/stablecoin/mock" "github.com/NibiruChain/nibiru/x/stablecoin/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" "github.com/NibiruChain/nibiru/x/testutil/sample" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) func TestKeeper_GetStableMarketCap(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(false) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(false) k := nibiruApp.StablecoinKeeper // We set some supply err := k.BankKeeper.MintCoins(ctx, types.ModuleName, sdktypes.NewCoins( - sdktypes.NewInt64Coin(common.StableDenom, 1_000_000), + sdktypes.NewInt64Coin(common.DenomStable, 1_000_000), )) require.NoError(t, err) @@ -31,7 +31,7 @@ func TestKeeper_GetStableMarketCap(t *testing.T) { } func TestKeeper_GetGovMarketCap(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(false) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(false) keeper := nibiruApp.StablecoinKeeper poolAccountAddr := sample.AccAddress() @@ -41,11 +41,11 @@ func TestKeeper_GetGovMarketCap(t *testing.T) { } poolAssets := []dextypes.PoolAsset{ { - Token: sdktypes.NewInt64Coin(common.GovDenom, 2_000_000), + Token: sdktypes.NewInt64Coin(common.DenomGov, 2_000_000), Weight: sdktypes.NewInt(100), }, { - Token: sdktypes.NewInt64Coin(common.StableDenom, 1_000_000), + Token: sdktypes.NewInt64Coin(common.DenomStable, 1_000_000), Weight: sdktypes.NewInt(100), }, } @@ -56,7 +56,7 @@ func TestKeeper_GetGovMarketCap(t *testing.T) { // We set some supply err = keeper.BankKeeper.MintCoins(ctx, types.ModuleName, sdktypes.NewCoins( - sdktypes.NewInt64Coin(common.GovDenom, 1_000_000), + sdktypes.NewInt64Coin(common.DenomGov, 1_000_000), )) require.NoError(t, err) @@ -67,7 +67,7 @@ func TestKeeper_GetGovMarketCap(t *testing.T) { } func TestKeeper_GetLiquidityRatio_AndBands(t *testing.T) { - nibiruApp, ctx := testutilapp.NewNibiruApp(false) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(false) keeper := nibiruApp.StablecoinKeeper poolAccountAddr := sample.AccAddress() @@ -77,11 +77,11 @@ func TestKeeper_GetLiquidityRatio_AndBands(t *testing.T) { } poolAssets := []dextypes.PoolAsset{ { - Token: sdktypes.NewInt64Coin(common.GovDenom, 2_000_000), + Token: sdktypes.NewInt64Coin(common.DenomGov, 2_000_000), Weight: sdktypes.NewInt(100), }, { - Token: sdktypes.NewInt64Coin(common.StableDenom, 1_000_000), + Token: sdktypes.NewInt64Coin(common.DenomStable, 1_000_000), Weight: sdktypes.NewInt(100), }, } @@ -92,12 +92,12 @@ func TestKeeper_GetLiquidityRatio_AndBands(t *testing.T) { // We set some supply err = keeper.BankKeeper.MintCoins(ctx, types.ModuleName, sdktypes.NewCoins( - sdktypes.NewInt64Coin(common.GovDenom, 1_000_000), + sdktypes.NewInt64Coin(common.DenomGov, 1_000_000), )) require.NoError(t, err) err = keeper.BankKeeper.MintCoins(ctx, types.ModuleName, sdktypes.NewCoins( - sdktypes.NewInt64Coin(common.StableDenom, 1_000_000), + sdktypes.NewInt64Coin(common.DenomStable, 1_000_000), )) require.NoError(t, err) diff --git a/x/stablecoin/simulation/msg.go b/x/stablecoin/simulation/msg.go index baaac7e46..4cd338d00 100644 --- a/x/stablecoin/simulation/msg.go +++ b/x/stablecoin/simulation/msg.go @@ -23,7 +23,7 @@ func SimulateMsgMintStable( ) (simtypes.OperationMsg, []simtypes.FutureOperation, error) { simAcc, _ := simtypes.RandomAcc(r, accs) // How much stable should get minted? - simStable := sdk.NewCoin(common.StableDenom, sdk.NewInt(100)) + simStable := sdk.NewCoin(common.DenomStable, sdk.NewInt(100)) msg := &types.MsgMintStable{ Creator: simAcc.Address.String(), Stable: simStable, diff --git a/x/stablecoin/types/expected_keepers.go b/x/stablecoin/types/expected_keepers.go index 4ab30d463..c90ebc089 100644 --- a/x/stablecoin/types/expected_keepers.go +++ b/x/stablecoin/types/expected_keepers.go @@ -41,11 +41,9 @@ type PricefeedKeeper interface { ) (pftypes.CurrentPrice, error) GetCurrentPrices(ctx sdk.Context) pftypes.CurrentPrices GetRawPrices(ctx sdk.Context, marketId string) pftypes.PostedPrices - GetPair(ctx sdk.Context, pairID string) (pftypes.Pair, bool) - GetPairs(ctx sdk.Context) pftypes.Pairs - GetOracle(ctx sdk.Context, pairID string, address sdk.AccAddress, - ) (sdk.AccAddress, error) - GetOracles(ctx sdk.Context, pairID string) ([]sdk.AccAddress, error) + IsWhitelistedOracle(ctx sdk.Context, pairID string, address sdk.AccAddress, + ) bool + GetOraclesForPair(ctx sdk.Context, pairID string) (oracles []sdk.AccAddress) SetCurrentPrices(ctx sdk.Context, token0 string, token1 string) error } diff --git a/x/stablecoin/types/expected_keepers_test.go b/x/stablecoin/types/expected_keepers_test.go index e9592158f..3a539d503 100644 --- a/x/stablecoin/types/expected_keepers_test.go +++ b/x/stablecoin/types/expected_keepers_test.go @@ -5,7 +5,7 @@ import ( "testing" sctypes "github.com/NibiruChain/nibiru/x/stablecoin/types" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" "github.com/stretchr/testify/assert" ) @@ -19,7 +19,7 @@ func TestExpectedKeepers(t *testing.T) { appKeeper interface{} } - nibiruApp, _ := testutilapp.NewNibiruApp(true) + nibiruApp, _ := testapp.NewNibiruAppAndContext(true) testCases := []TestCase{ { name: "PricefeedKeeper from x/pricefeed", diff --git a/x/stablecoin/types/genesis.go b/x/stablecoin/types/genesis.go index 780ac94cf..439b6fc07 100644 --- a/x/stablecoin/types/genesis.go +++ b/x/stablecoin/types/genesis.go @@ -13,7 +13,7 @@ const DefaultIndex uint64 = 1 func DefaultGenesis() *GenesisState { return &GenesisState{ Params: DefaultParams(), - ModuleAccountBalance: sdk.NewCoin(common.CollDenom, sdk.ZeroInt()), + ModuleAccountBalance: sdk.NewCoin(common.DenomColl, sdk.ZeroInt()), } } diff --git a/x/stablecoin/types/params.go b/x/stablecoin/types/params.go index 37b62bcbf..b0c239ffd 100644 --- a/x/stablecoin/types/params.go +++ b/x/stablecoin/types/params.go @@ -237,7 +237,7 @@ func validateEfFeeRatio(i interface{}) error { } func validateDistrEpochIdentifier(i interface{}) error { - _, err := getAsString(i) + _, err := getString(i) if err != nil { return err } @@ -289,7 +289,7 @@ func validatePriceUpperBound(i interface{}) error { } } -func getAsString(i interface{}) (string, error) { +func getString(i interface{}) (string, error) { value, ok := i.(string) if !ok { return "invalid", fmt.Errorf("invalid parameter type: %T", i) diff --git a/x/testutil/app/testapp.go b/x/testutil/app/testapp.go deleted file mode 100644 index fa93cded6..000000000 --- a/x/testutil/app/testapp.go +++ /dev/null @@ -1,68 +0,0 @@ -package app - -import ( - "encoding/json" - "os" - "path/filepath" - - "github.com/cosmos/cosmos-sdk/simapp" - sdk "github.com/cosmos/cosmos-sdk/types" - abci "github.com/tendermint/tendermint/abci/types" - "github.com/tendermint/tendermint/libs/log" - tmproto "github.com/tendermint/tendermint/proto/tendermint/types" - tmdb "github.com/tendermint/tm-db" - - "github.com/NibiruChain/nibiru/app" -) - -// New creates application instance with in-memory database and disabled logging. -func NewTestApp(shouldUseDefaultGenesis bool) *app.NibiruApp { - userHomeDir, err := os.UserHomeDir() - if err != nil { - panic(err) - } - - nodeHome := filepath.Join(userHomeDir, ".nibid") - db := tmdb.NewMemDB() - logger := log.NewNopLogger() - - encoding := app.MakeTestEncodingConfig() - - testApp := app.NewNibiruApp( - logger, - db, - /*traceStore=*/ nil, - /*loadLatest=*/ true, - /*skipUpgradeHeights=*/ map[int64]bool{}, - /*homePath=*/ nodeHome, - /*invCheckPeriod=*/ 0, - /*encodingConfig=*/ encoding, - /*appOpts=*/ simapp.EmptyAppOptions{}, - ) - - var stateBytes = []byte("{}") - if shouldUseDefaultGenesis { - genesisState := app.NewDefaultGenesisState(encoding.Marshaler) - stateBytes, err = json.MarshalIndent(genesisState, "", " ") - if err != nil { - panic(err) - } - } - - // InitChain updates deliverState which is required when app.NewContext is called - testApp.InitChain(abci.RequestInitChain{ - ConsensusParams: simapp.DefaultConsensusParams, - AppStateBytes: stateBytes, - }) - - return testApp -} - -/* NewNibiruApp creates an 'app.NibiruApp' instance with an in-memory - 'tmdb.MemDB' and fresh 'sdk.Context'. */ -func NewNibiruApp(shouldUseDefaultGenesis bool) (*app.NibiruApp, sdk.Context) { - newNibiruApp := NewTestApp(shouldUseDefaultGenesis) - ctx := newNibiruApp.NewContext(false, tmproto.Header{}) - - return newNibiruApp, ctx -} diff --git a/x/testutil/cli/network.go b/x/testutil/cli/network.go index a85f7c885..710476861 100644 --- a/x/testutil/cli/network.go +++ b/x/testutil/cli/network.go @@ -27,6 +27,7 @@ import ( "github.com/cosmos/cosmos-sdk/server/api" srvconfig "github.com/cosmos/cosmos-sdk/server/config" servertypes "github.com/cosmos/cosmos-sdk/server/types" + storetypes "github.com/cosmos/cosmos-sdk/store/types" sdktestutil "github.com/cosmos/cosmos-sdk/testutil" sdk "github.com/cosmos/cosmos-sdk/types" @@ -45,7 +46,7 @@ import ( "github.com/NibiruChain/nibiru/app" "github.com/NibiruChain/nibiru/x/common" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" ) // package-wide network lock to only allow one test network at a time @@ -132,9 +133,8 @@ func DefaultFeeString(denom string) string { return fmt.Sprintf("--%s=%s", flags.FlagFees, feeCoins.String()) } -// DefaultConfig returns a default configuration suitable for nearly all -// testing requirements. -func DefaultConfig() Config { +// BuildNetworkConfig returns a configuration for a local in-testing network +func BuildNetworkConfig(appGenesis app.GenesisState) Config { encCfg := app.MakeTestEncodingConfig() return Config{ @@ -144,22 +144,22 @@ func DefaultConfig() Config { InterfaceRegistry: encCfg.InterfaceRegistry, AccountRetriever: authtypes.AccountRetriever{}, AppConstructor: func(val Validator) servertypes.Application { - return testutilapp.NewTestApp(true) + return testapp.NewNibiruAppWithGenesis(appGenesis) }, - GenesisState: app.ModuleBasics.DefaultGenesis(encCfg.Marshaler), + GenesisState: appGenesis, TimeoutCommit: time.Second / 2, ChainID: "chain-" + tmrand.NewRand().Str(6), NumValidators: 1, BondDenom: sdk.DefaultBondDenom, // TODO(https://github.com/NibiruChain/nibiru/issues/582): remove 'stake' denom and replace with 'unibi' - MinGasPrices: fmt.Sprintf("0.000006%s", common.GovDenom), + MinGasPrices: fmt.Sprintf("0.000006%s", common.DenomGov), AccountTokens: sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction), StakingTokens: sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction), BondedTokens: sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction), StartingTokens: sdk.NewCoins( - sdk.NewCoin(common.StableDenom, sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)), - sdk.NewCoin(common.GovDenom, sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction)), - sdk.NewCoin(common.CollDenom, sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)), - sdk.NewCoin(common.TestTokenDenom, sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction)), + sdk.NewCoin(common.DenomStable, sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)), + sdk.NewCoin(common.DenomGov, sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction)), + sdk.NewCoin(common.DenomColl, sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)), + sdk.NewCoin(common.DenomTestToken, sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction)), ), PruningStrategy: storetypes.PruningOptionNothing, CleanupDir: true, @@ -169,7 +169,7 @@ func DefaultConfig() Config { } // New creates a new Network for integration tests. -func New(t *testing.T, cfg Config) *Network { +func NewNetwork(t *testing.T, cfg Config) *Network { // only one caller/test can create and use a network at a time t.Log("acquiring test network lock") lock.Lock() @@ -375,8 +375,8 @@ func New(t *testing.T, cfg Config) *Network { ValAddress: sdk.ValAddress(addr), } } - - require.NoError(t, initGenFiles(cfg, genAccounts, genBalances, genFiles)) + cfg, err = initGenFiles(cfg, genAccounts, genBalances, genFiles) + require.NoError(t, err) require.NoError(t, collectGenFiles(cfg, network.Validators, network.BaseDir)) t.Log("starting test network...") diff --git a/x/testutil/cli/network_test.go b/x/testutil/cli/network_test.go index 061f53923..75790248f 100644 --- a/x/testutil/cli/network_test.go +++ b/x/testutil/cli/network_test.go @@ -29,7 +29,7 @@ func (s *IntegrationTestSuite) SetupSuite() { s.T().Log("setting up integration test suite") - s.network = network.New(s.T(), cli.DefaultConfig()) + s.network = network.New(s.T(), network.DefaultConfig()) s.Require().NotNil(s.network) _, err := s.network.WaitForHeight(1) diff --git a/x/testutil/cli/query.go b/x/testutil/cli/query.go index 4affd566d..ca1fcdd6d 100644 --- a/x/testutil/cli/query.go +++ b/x/testutil/cli/query.go @@ -80,8 +80,13 @@ func ExecQuery(network *Network, cmd *cobra.Command, args []string, result codec } } -func QueryVpoolReserveAssets(ctx client.Context, pair common.AssetPair) (vpooltypes.QueryReserveAssetsResponse, error) { - out, err := clitestutil.ExecTestCLICmd(ctx, vpoolcli.CmdGetVpoolReserveAssets(), []string{pair.String(), fmt.Sprintf("--%s=json", tmcli.OutputFlag)}) +func QueryVpoolReserveAssets(ctx client.Context, pair common.AssetPair, +) (vpooltypes.QueryReserveAssetsResponse, error) { + out, err := clitestutil.ExecTestCLICmd( + ctx, + vpoolcli.CmdGetVpoolReserveAssets(), + []string{pair.String(), + fmt.Sprintf("--%s=json", tmcli.OutputFlag)}) if err != nil { return vpooltypes.QueryReserveAssetsResponse{}, err } diff --git a/x/testutil/cli/tx.go b/x/testutil/cli/tx.go index d953c784a..e82aae86b 100644 --- a/x/testutil/cli/tx.go +++ b/x/testutil/cli/tx.go @@ -53,7 +53,7 @@ func ExecTx(network *Network, cmd *cobra.Command, txSender sdk.AccAddress, args } options := execTxOptions{ - fees: sdk.NewCoins(sdk.NewCoin(common.GovDenom, sdk.NewInt(10))), + fees: sdk.NewCoins(sdk.NewCoin(common.DenomGov, sdk.NewInt(10))), skipConfirmation: true, broadcastMode: flags.BroadcastBlock, } diff --git a/x/testutil/cli/util.go b/x/testutil/cli/util.go index 91d72300c..b16633be1 100644 --- a/x/testutil/cli/util.go +++ b/x/testutil/cli/util.go @@ -9,6 +9,8 @@ import ( "github.com/cosmos/cosmos-sdk/codec" tmtypes "github.com/tendermint/tendermint/abci/types" + "github.com/NibiruChain/nibiru/x/testutil/testapp" + "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/server/api" servergrpc "github.com/cosmos/cosmos-sdk/server/grpc" @@ -157,14 +159,19 @@ func collectGenFiles(cfg Config, vals []*Validator, outputDir string) error { return nil } -func initGenFiles(cfg Config, genAccounts []authtypes.GenesisAccount, genBalances []banktypes.Balance, genFiles []string) error { +func initGenFiles( + cfg Config, + genAccounts []authtypes.GenesisAccount, + genBalances []banktypes.Balance, + genFiles []string, +) (Config, error) { // set the accounts in the genesis state var authGenState authtypes.GenesisState cfg.Codec.MustUnmarshalJSON(cfg.GenesisState[authtypes.ModuleName], &authGenState) accounts, err := authtypes.PackAccounts(genAccounts) if err != nil { - return err + return cfg, err } authGenState.Accounts = append(authGenState.Accounts, accounts...) @@ -173,13 +180,13 @@ func initGenFiles(cfg Config, genAccounts []authtypes.GenesisAccount, genBalance // set the balances in the genesis state var bankGenState banktypes.GenesisState cfg.Codec.MustUnmarshalJSON(cfg.GenesisState[banktypes.ModuleName], &bankGenState) - bankGenState.Balances = append(bankGenState.Balances, genBalances...) cfg.GenesisState[banktypes.ModuleName] = cfg.Codec.MustMarshalJSON(&bankGenState) + cfg.GenesisState = testapp.NewTestGenesisState(cfg.Codec, cfg.GenesisState) appGenStateJSON, err := json.MarshalIndent(cfg.GenesisState, "", " ") if err != nil { - return err + return cfg, err } genDoc := types.GenesisDoc{ @@ -191,11 +198,11 @@ func initGenFiles(cfg Config, genAccounts []authtypes.GenesisAccount, genBalance // generate empty genesis files for each validator and save for i := 0; i < cfg.NumValidators; i++ { if err := genDoc.SaveAs(genFiles[i]); err != nil { - return err + return cfg, err } } - return nil + return cfg, nil } func writeFile(name string, dir string, contents []byte) error { diff --git a/x/testutil/keeper/pricefeed.go b/x/testutil/keeper/pricefeed.go index 7fe33bc5f..7cc80ad9f 100644 --- a/x/testutil/keeper/pricefeed.go +++ b/x/testutil/keeper/pricefeed.go @@ -18,6 +18,7 @@ import ( "github.com/NibiruChain/nibiru/x/pricefeed/types" ) +// NOTE This should be inside the x/pricefeed/keeper module, not here. func PricefeedKeeper(t testing.TB) (keeper.Keeper, sdk.Context) { storeKey := sdk.NewKVStoreKey(types.StoreKey) memStoreKey := storetypes.NewMemoryStoreKey(types.MemStoreKey) diff --git a/x/testutil/mock/perp_interfaces.go b/x/testutil/mock/perp_interfaces.go index 838e38be7..b86a40c2d 100644 --- a/x/testutil/mock/perp_interfaces.go +++ b/x/testutil/mock/perp_interfaces.go @@ -284,56 +284,25 @@ func (mr *MockPricefeedKeeperMockRecorder) GetCurrentTWAPPrice(arg0, arg1, arg2 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentTWAPPrice", reflect.TypeOf((*MockPricefeedKeeper)(nil).GetCurrentTWAPPrice), arg0, arg1, arg2) } -// GetOracle mocks base method. -func (m *MockPricefeedKeeper) GetOracle(arg0 types2.Context, arg1 string, arg2 types2.AccAddress) (types2.AccAddress, error) { +// GetOraclesForPair mocks base method. +func (m *MockPricefeedKeeper) GetOraclesForPair(arg0 types2.Context, arg1 string) []types2.AccAddress { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetOracle", arg0, arg1, arg2) - ret0, _ := ret[0].(types2.AccAddress) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetOracle indicates an expected call of GetOracle. -func (mr *MockPricefeedKeeperMockRecorder) GetOracle(arg0, arg1, arg2 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOracle", reflect.TypeOf((*MockPricefeedKeeper)(nil).GetOracle), arg0, arg1, arg2) -} - -// GetOracles mocks base method. -func (m *MockPricefeedKeeper) GetOracles(arg0 types2.Context, arg1 string) ([]types2.AccAddress, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetOracles", arg0, arg1) + ret := m.ctrl.Call(m, "GetOraclesForPair", arg0, arg1) ret0, _ := ret[0].([]types2.AccAddress) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetOracles indicates an expected call of GetOracles. -func (mr *MockPricefeedKeeperMockRecorder) GetOracles(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOracles", reflect.TypeOf((*MockPricefeedKeeper)(nil).GetOracles), arg0, arg1) -} - -// GetPair mocks base method. -func (m *MockPricefeedKeeper) GetPair(arg0 types2.Context, arg1 string) (types0.Pair, bool) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetPair", arg0, arg1) - ret0, _ := ret[0].(types0.Pair) - ret1, _ := ret[1].(bool) - return ret0, ret1 + return ret0 } -// GetPair indicates an expected call of GetPair. -func (mr *MockPricefeedKeeperMockRecorder) GetPair(arg0, arg1 interface{}) *gomock.Call { +// GetOraclesForPair indicates an expected call of GetOraclesForPair. +func (mr *MockPricefeedKeeperMockRecorder) GetOraclesForPair(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPair", reflect.TypeOf((*MockPricefeedKeeper)(nil).GetPair), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOraclesForPair", reflect.TypeOf((*MockPricefeedKeeper)(nil).GetOraclesForPair), arg0, arg1) } // GetPairs mocks base method. -func (m *MockPricefeedKeeper) GetPairs(arg0 types2.Context) types0.Pairs { +func (m *MockPricefeedKeeper) GetPairs(arg0 types2.Context) common.AssetPairs { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPairs", arg0) - ret0, _ := ret[0].(types0.Pairs) + ret0, _ := ret[0].(common.AssetPairs) return ret0 } @@ -357,6 +326,34 @@ func (mr *MockPricefeedKeeperMockRecorder) GetRawPrices(arg0, arg1 interface{}) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawPrices", reflect.TypeOf((*MockPricefeedKeeper)(nil).GetRawPrices), arg0, arg1) } +// IsActivePair mocks base method. +func (m *MockPricefeedKeeper) IsActivePair(arg0 types2.Context, arg1 string) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsActivePair", arg0, arg1) + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsActivePair indicates an expected call of IsActivePair. +func (mr *MockPricefeedKeeperMockRecorder) IsActivePair(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActivePair", reflect.TypeOf((*MockPricefeedKeeper)(nil).IsActivePair), arg0, arg1) +} + +// IsWhitelistedOracle mocks base method. +func (m *MockPricefeedKeeper) IsWhitelistedOracle(arg0 types2.Context, arg1 string, arg2 types2.AccAddress) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsWhitelistedOracle", arg0, arg1, arg2) + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsWhitelistedOracle indicates an expected call of IsWhitelistedOracle. +func (mr *MockPricefeedKeeperMockRecorder) IsWhitelistedOracle(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWhitelistedOracle", reflect.TypeOf((*MockPricefeedKeeper)(nil).IsWhitelistedOracle), arg0, arg1, arg2) +} + // SetCurrentPrices mocks base method. func (m *MockPricefeedKeeper) SetCurrentPrices(arg0 types2.Context, arg1, arg2 string) error { m.ctrl.T.Helper() @@ -439,18 +436,18 @@ func (mr *MockVpoolKeeperMockRecorder) GetBaseAssetTWAP(arg0, arg1, arg2, arg3, } // GetCurrentTWAPPrice mocks base method. -func (m *MockVpoolKeeper) GetCurrentTWAPPrice(arg0 types2.Context, arg1, arg2 string) (types1.CurrentTWAP, error) { +func (m *MockVpoolKeeper) GetCurrentTWAPPrice(arg0 types2.Context, arg1 common.AssetPair) (types1.CurrentTWAP, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCurrentTWAPPrice", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetCurrentTWAPPrice", arg0, arg1) ret0, _ := ret[0].(types1.CurrentTWAP) ret1, _ := ret[1].(error) return ret0, ret1 } // GetCurrentTWAPPrice indicates an expected call of GetCurrentTWAPPrice. -func (mr *MockVpoolKeeperMockRecorder) GetCurrentTWAPPrice(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockVpoolKeeperMockRecorder) GetCurrentTWAPPrice(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentTWAPPrice", reflect.TypeOf((*MockVpoolKeeper)(nil).GetCurrentTWAPPrice), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentTWAPPrice", reflect.TypeOf((*MockVpoolKeeper)(nil).GetCurrentTWAPPrice), arg0, arg1) } // GetQuoteAssetPrice mocks base method. diff --git a/x/testutil/testapp/testapp.go b/x/testutil/testapp/testapp.go new file mode 100644 index 000000000..5874f25b9 --- /dev/null +++ b/x/testutil/testapp/testapp.go @@ -0,0 +1,168 @@ +package testapp + +import ( + "encoding/json" + "os" + "path/filepath" + + "time" + + "github.com/cosmos/cosmos-sdk/simapp" + abci "github.com/tendermint/tendermint/abci/types" + "github.com/tendermint/tendermint/libs/log" + tmproto "github.com/tendermint/tendermint/proto/tendermint/types" + tmdb "github.com/tendermint/tm-db" + + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/NibiruChain/nibiru/app" + "github.com/NibiruChain/nibiru/x/common" + pricefeedtypes "github.com/NibiruChain/nibiru/x/pricefeed/types" + + "github.com/cosmos/cosmos-sdk/codec" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" +) + +// NewTestApp creates an application instance ('app.NibiruApp') with an in-memory +// database ('tmdb.MemDB') and disabled logging. It either uses the application's +// default genesis state or a blank one. +func NewNibiruApp(shouldUseDefaultGenesis bool) *app.NibiruApp { + encoding := app.MakeTestEncodingConfig() + var appGenesis app.GenesisState + if shouldUseDefaultGenesis { + appGenesis = app.NewDefaultGenesisState(encoding.Marshaler) + } + return NewNibiruAppWithGenesis(appGenesis) +} + +// NewNibiruApp creates an 'app.NibiruApp' instance with an in-memory +// 'tmdb.MemDB' and fresh 'sdk.Context'. +func NewNibiruAppAndContext(shouldUseDefaultGenesis bool) (*app.NibiruApp, sdk.Context) { + newNibiruApp := NewNibiruApp(shouldUseDefaultGenesis) + ctx := newNibiruApp.NewContext(false, tmproto.Header{}) + + return newNibiruApp, ctx +} + +// NewTestAppWithGenesis initializes a chain with the given genesis state to +// creates an application instance ('app.NibiruApp'). This app uses an +// in-memory database ('tmdb.MemDB') and has logging disabled. +func NewNibiruAppWithGenesis(gen app.GenesisState) *app.NibiruApp { + userHomeDir, err := os.UserHomeDir() + if err != nil { + panic(err) + } + + nodeHome := filepath.Join(userHomeDir, ".nibid") + db := tmdb.NewMemDB() + logger := log.NewNopLogger() + + encoding := app.MakeTestEncodingConfig() + + nibiruApp := app.NewNibiruApp( + logger, + db, + /*traceStore=*/ nil, + /*loadLatest=*/ true, + /*skipUpgradeHeights=*/ map[int64]bool{}, + /*homePath=*/ nodeHome, + /*invCheckPeriod=*/ 0, + /*encodingConfig=*/ encoding, + /*appOpts=*/ simapp.EmptyAppOptions{}, + ) + + stateBytes, err := json.MarshalIndent(gen, "", " ") + if err != nil { + panic(err) + } + + nibiruApp.InitChain(abci.RequestInitChain{ + ConsensusParams: simapp.DefaultConsensusParams, + AppStateBytes: stateBytes, + }) + + return nibiruApp +} + +// ---------------------------------------------------------------------------- +// Genesis +// ---------------------------------------------------------------------------- + +const ( + GenOracleAddress = "nibi1zuxt7fvuxgj69mjxu3auca96zemqef5u2yemly" + GenOracleMnemonic = "kit soon capital dry sadness balance rival embark behind coast online struggle deer crush hospital during man monkey prison action custom wink utility arrive" +) + +/* NewTestGenesisStateFromDefault returns 'NewGenesisState' using the default +genesis as input. The blockchain genesis state is represented as a map from module +identifier strings to raw json messages. */ +func NewTestGenesisStateFromDefault() app.GenesisState { + encodingConfig := app.MakeTestEncodingConfig() + codec := encodingConfig.Marshaler + genState := app.NewDefaultGenesisState(codec) + return NewTestGenesisState(codec, genState) +} + +/* +NewTestGenesisState transforms 'inGenState' to add genesis parameter changes +that are well suited to integration testing, then returns the transformed genesis. +The blockchain genesis state is represented as a map from module identifier strings +to raw json messages. + +Args: +- codec: Serializer for the module genesis state proto.Messages +- inGenState: Input genesis state before the custom test setup is applied +*/ +func NewTestGenesisState(codec codec.Codec, inGenState app.GenesisState, +) (testGenState app.GenesisState) { + testGenState = inGenState + + // Set short voting period to allow fast gov proposals in tests + var govGenState govtypes.GenesisState + codec.MustUnmarshalJSON(testGenState[govtypes.ModuleName], &govGenState) + govGenState.VotingParams.VotingPeriod = time.Second * 20 + govGenState.DepositParams.MinDeposit = sdk.NewCoins( + sdk.NewInt64Coin(common.DenomGov, 1_000_000)) // min deposit of 1 NIBI + bz := codec.MustMarshalJSON(&govGenState) + testGenState[govtypes.ModuleName] = bz + + // pricefeed genesis state + // pfGenState := pricefeedtypes.GenesisState{} + // codec.MustUnmarshalJSON(testGenState[pricefeedtypes.ModuleName], &pfGenState) + pfGenState := PricefeedGenesis() + bz = codec.MustMarshalJSON(&pfGenState) + testGenState[pricefeedtypes.ModuleName] = bz + + return testGenState +} + +// ---------------------------------------------------------------------------- +// Module types.GenesisState functions + +/* PricefeedGenesis returns an x/pricefeed GenesisState with additional +configuration for convenience during integration tests. */ +func PricefeedGenesis() pricefeedtypes.GenesisState { + oracle := sdk.MustAccAddressFromBech32(GenOracleAddress) + oracleStrings := []string{oracle.String()} + + var gen pricefeedtypes.GenesisState + pairs := pricefeedtypes.DefaultPairs + gen.Params.Pairs = pairs + gen.PostedPrices = []pricefeedtypes.PostedPrice{ + { + PairID: pairs[0].String(), // PairGovStable + Oracle: oracle.String(), + Price: sdk.NewDec(10), + Expiry: time.Now().Add(1 * time.Hour), + }, + { + PairID: pairs[1].String(), // PairCollStable + Oracle: oracle.String(), + Price: sdk.OneDec(), + Expiry: time.Now().Add(1 * time.Hour), + }, + } + gen.GenesisOracles = oracleStrings + + return gen +} diff --git a/x/testutil/testapp/testapp_test.go b/x/testutil/testapp/testapp_test.go new file mode 100644 index 000000000..ba29f0a0d --- /dev/null +++ b/x/testutil/testapp/testapp_test.go @@ -0,0 +1,95 @@ +package testapp_test + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/suite" + tmproto "github.com/tendermint/tendermint/proto/tendermint/types" + + "github.com/NibiruChain/nibiru/app" + "github.com/NibiruChain/nibiru/x/common" + pricefeedtypes "github.com/NibiruChain/nibiru/x/pricefeed/types" + "github.com/NibiruChain/nibiru/x/testutil/testapp" +) + +type TestappSuite struct { + suite.Suite + + genOracle sdk.AccAddress + pairs common.AssetPairs +} + +func (s *TestappSuite) SetupSuite() { + app.SetPrefixes(app.AccountAddressPrefix) + s.genOracle = sdk.MustAccAddressFromBech32(testapp.GenOracleAddress) + s.pairs = pricefeedtypes.DefaultPairs +} + +// TestPricefeedGenesis verifies that the expected pricefeed state for integration tests +func (s *TestappSuite) TestPricefeedGenesis() { + genPf := testapp.PricefeedGenesis() + s.Assert().EqualValues(pricefeedtypes.NewParams(s.pairs), genPf.Params) + s.Assert().EqualValues(pricefeedtypes.NewParams(s.pairs), genPf.Params) + s.Assert().EqualValues(s.pairs[0].String(), genPf.PostedPrices[0].PairID) + s.Assert().EqualValues(s.pairs[1].String(), genPf.PostedPrices[1].PairID) + expectedGenesisOracles := []string{s.genOracle.String()} + for _, oracleStr := range expectedGenesisOracles { + s.Assert().Contains(genPf.GenesisOracles, oracleStr) + } +} + +func (s *TestappSuite) TestNewTestGenesisState() { + encodingConfig := app.MakeTestEncodingConfig() + codec := encodingConfig.Marshaler + + defaultGenState := app.NewDefaultGenesisState(codec) + testGenState := testapp.NewTestGenesisStateFromDefault() + + var testGenPfState pricefeedtypes.GenesisState + testGenPfStateJSON := testGenState[pricefeedtypes.ModuleName] + codec.MustUnmarshalJSON(testGenPfStateJSON, &testGenPfState) + bzTest := codec.MustMarshalJSON(&testGenPfState) + + var defaultGenPfState pricefeedtypes.GenesisState + defaultGenPfStateJSON := defaultGenState[pricefeedtypes.ModuleName] + codec.MustUnmarshalJSON(defaultGenPfStateJSON, &defaultGenPfState) + bzDefault := codec.MustMarshalJSON(&defaultGenPfState) + + s.Assert().NotEqualValues(bzTest, bzDefault) + s.Assert().NotEqualValues(testGenPfState, defaultGenPfState) + + s.Assert().EqualValues(pricefeedtypes.NewParams(s.pairs), testGenPfState.Params) + s.Assert().EqualValues(pricefeedtypes.NewParams(s.pairs), testGenPfState.Params) + s.Assert().EqualValues(s.pairs[0].String(), testGenPfState.PostedPrices[0].PairID) + s.Assert().EqualValues(s.pairs[1].String(), testGenPfState.PostedPrices[1].PairID) + expectedGenesisOracles := []string{s.genOracle.String()} + for _, oracleStr := range expectedGenesisOracles { + s.Assert().Contains(testGenPfState.GenesisOracles, oracleStr) + } +} + +func (s *TestappSuite) TestPricefeedGenesis_PostedPrices() { + s.T().Log("no prices posted for default genesis") + nibiruApp := testapp.NewNibiruApp(true) + ctx := nibiruApp.NewContext(false, tmproto.Header{}) + currentPrices := nibiruApp.PricefeedKeeper.GetCurrentPrices(ctx) + s.Assert().Len(currentPrices, 0) + + s.T().Log("prices posted for testing genesis") + nibiruApp = testapp.NewNibiruAppWithGenesis(testapp.NewTestGenesisStateFromDefault()) + ctx = nibiruApp.NewContext(false, tmproto.Header{}) + oracles := []sdk.AccAddress{s.genOracle} + oracleMap := nibiruApp.PricefeedKeeper.GetOraclesForPairs(ctx, s.pairs) + for _, pair := range s.pairs { + s.Assert().EqualValues(oracles, oracleMap[pair]) + } + currentPrices = nibiruApp.PricefeedKeeper.GetCurrentPrices(ctx) + s.Assert().Len(currentPrices, 2) + s.Assert().Equal(common.PairGovStable.String(), currentPrices[0].PairID) + s.Assert().Equal(common.PairCollStable.String(), currentPrices[1].PairID) +} + +func TestTestappSuite(t *testing.T) { + suite.Run(t, new(TestappSuite)) +} diff --git a/x/vpool/client/cli/query.go b/x/vpool/client/cli/query.go index a45b9afec..2cd1bec1a 100644 --- a/x/vpool/client/cli/query.go +++ b/x/vpool/client/cli/query.go @@ -52,7 +52,7 @@ func CmdGetVpoolReserveAssets() *cobra.Command { queryClient := types.NewQueryClient(clientCtx) - tokenPair, err := common.NewAssetPairFromStr(args[0]) + tokenPair, err := common.NewAssetPair(args[0]) if err != nil { return err } @@ -117,7 +117,7 @@ func CmdGetBaseAssetPrice() *cobra.Command { return err } - tokenPair, err := common.NewAssetPairFromStr(args[0]) + tokenPair, err := common.NewAssetPair(args[0]) if err != nil { return err } diff --git a/x/vpool/genesis_test.go b/x/vpool/genesis_test.go index d174d3d11..366c7c24f 100644 --- a/x/vpool/genesis_test.go +++ b/x/vpool/genesis_test.go @@ -6,7 +6,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/stretchr/testify/require" - testutilapp "github.com/NibiruChain/nibiru/x/testutil/app" + "github.com/NibiruChain/nibiru/x/testutil/testapp" "github.com/NibiruChain/nibiru/x/vpool" "github.com/NibiruChain/nibiru/x/vpool/types" ) @@ -34,7 +34,7 @@ func TestGenesis(t *testing.T) { genesisState := types.GenesisState{Vpools: vpools} - nibiruApp, ctx := testutilapp.NewNibiruApp(true) + nibiruApp, ctx := testapp.NewNibiruAppAndContext(true) k := nibiruApp.VpoolKeeper vpool.InitGenesis(ctx, k, genesisState) diff --git a/x/vpool/keeper/keeper.go b/x/vpool/keeper/keeper.go index 1bca539ec..45c1b5279 100644 --- a/x/vpool/keeper/keeper.go +++ b/x/vpool/keeper/keeper.go @@ -196,7 +196,7 @@ func (k Keeper) SwapQuoteForBase( func (k Keeper) checkFluctuationLimitRatio(ctx sdk.Context, pool *types.Pool) error { if pool.FluctuationLimitRatio.GT(sdk.ZeroDec()) { - pair, err := common.NewAssetPairFromStr(pool.Pair) + pair, err := common.NewAssetPair(pool.Pair) if err != nil { return err } diff --git a/x/vpool/keeper/prices.go b/x/vpool/keeper/prices.go index 5781402e4..b56e8dd90 100644 --- a/x/vpool/keeper/prices.go +++ b/x/vpool/keeper/prices.go @@ -277,21 +277,15 @@ func (k Keeper) calcTwap( } // GetCurrentTWAPPrice fetches the current median price of all oracles for a specific market -func (k Keeper) GetCurrentTWAPPrice(ctx sdk.Context, token0 string, token1 string) (types.CurrentTWAP, error) { +func (k Keeper) GetCurrentTWAPPrice(ctx sdk.Context, pair common.AssetPair) (types.CurrentTWAP, error) { // Ensure we still have valid prices - _, err := k.GetSpotPrice(ctx, common.AssetPair{ - Token0: token0, - Token1: token1, - }) + _, err := k.GetSpotPrice(ctx, pair) if err != nil { return types.CurrentTWAP{}, types.ErrNoValidPrice } - assetPair := common.AssetPair{Token0: token0, Token1: token1} - pairID := assetPair.Name() - store := ctx.KVStore(k.storeKey) - bz := store.Get(types.CurrentTWAPPriceKey("twap-" + pairID)) + bz := store.Get(types.CurrentTWAPPriceKey("twap-" + pair.String())) if bz == nil { return types.CurrentTWAP{}, types.ErrNoValidTWAP @@ -303,17 +297,6 @@ func (k Keeper) GetCurrentTWAPPrice(ctx sdk.Context, token0 string, token1 strin return types.CurrentTWAP{}, types.ErrNoValidPrice } - if !assetPair.IsProperOrder() { - // Return the inverse price if the tokens are not in "proper" order. - inversePrice := sdk.OneDec().Quo(price.Price) - return types.NewCurrentTWAP( - /* token0 */ token1, - /* token1 */ token0, - /* numerator */ price.Numerator, - /* denominator */ price.Denominator, - /* price */ inversePrice), nil - } - return price, nil } @@ -330,18 +313,17 @@ With */ func (k Keeper) UpdateTWAPPrice(ctx sdk.Context, pairID string) error { - tokens := common.DenomsFromPoolName(pairID) - token0, token1 := tokens[0], tokens[1] + pair, err := common.NewAssetPair(pairID) + if err != nil { + return err + } - currentPrice, err := k.GetSpotPrice(ctx, common.AssetPair{ - Token0: token0, - Token1: token1, - }) + currentPrice, err := k.GetSpotPrice(ctx, pair) if err != nil { return err } - currentTWAP, err := k.GetCurrentTWAPPrice(ctx, token0, token1) + currentTWAP, err := k.GetCurrentTWAPPrice(ctx, pair) // Err there means no twap price have been set yet for this pair if errors.Is(err, types.ErrNoValidTWAP) { currentTWAP = types.CurrentTWAP{ diff --git a/x/vpool/keeper/prices_test.go b/x/vpool/keeper/prices_test.go index 46307256d..02fd77b9a 100644 --- a/x/vpool/keeper/prices_test.go +++ b/x/vpool/keeper/prices_test.go @@ -543,7 +543,6 @@ func TestGetTWAPPrice(t *testing.T) { }, } - token0, token1 := BTCNusdPair.Token0, BTCNusdPair.Token1 initialTWAP := sdk.NewDec(40_000) for _, tc := range tests { tc := tc @@ -564,7 +563,8 @@ func TestGetTWAPPrice(t *testing.T) { err := keeper.UpdateTWAPPrice(cctx, BTCNusdPair.String()) require.NoError(t, err) // Make sure price gets initialized correctly when the pool gets created - twap, err := keeper.GetCurrentTWAPPrice(ctx, token0, token1) + pair := BTCNusdPair + twap, err := keeper.GetCurrentTWAPPrice(ctx, pair) require.NoError(t, err) require.EqualValues(t, initialTWAP, twap.Price) for i, p := range tc.positionUpdates { @@ -578,7 +578,7 @@ func TestGetTWAPPrice(t *testing.T) { require.NoError(t, err) err = keeper.UpdateTWAPPrice(cctx, BTCNusdPair.String()) require.NoError(t, err) - twapPrice, err := keeper.GetCurrentTWAPPrice(ctx, token0, token1) + twapPrice, err := keeper.GetCurrentTWAPPrice(ctx, pair) require.NoError(t, err) assert.Equal(t, tc.expectedPrices[i], twapPrice.Price) } diff --git a/x/vpool/keeper/query_server.go b/x/vpool/keeper/query_server.go index 78ffdeac5..4357f4e6b 100644 --- a/x/vpool/keeper/query_server.go +++ b/x/vpool/keeper/query_server.go @@ -31,7 +31,7 @@ func (q queryServer) ReserveAssets( ctx := sdk.UnwrapSDKContext(goCtx) - tokenPair, err := common.NewAssetPairFromStr(req.Pair) + tokenPair, err := common.NewAssetPair(req.Pair) if err != nil { return nil, status.Error(codes.InvalidArgument, err.Error()) } @@ -77,7 +77,7 @@ func (q queryServer) BaseAssetPrice( ctx := sdk.UnwrapSDKContext(goCtx) - pair, err := common.NewAssetPairFromStr(req.Pair) + pair, err := common.NewAssetPair(req.Pair) if err != nil { return nil, err } diff --git a/x/vpool/types/pool.go b/x/vpool/types/pool.go index f6e6e338f..4b9f21250 100644 --- a/x/vpool/types/pool.go +++ b/x/vpool/types/pool.go @@ -25,7 +25,7 @@ func NewPool( } func (p *Pool) GetAssetPair() common.AssetPair { - pair, err := common.NewAssetPairFromStr(p.Pair) + pair, err := common.NewAssetPair(p.Pair) if err != nil { panic(err) } @@ -158,5 +158,8 @@ Returns: */ func NewCurrentTWAP(token0 string, token1 string, numerator sdk.Dec, denominator sdk.Dec, price sdk.Dec) CurrentTWAP { assetPair := common.AssetPair{Token0: token0, Token1: token1} - return CurrentTWAP{PairID: assetPair.Name(), Numerator: numerator, Denominator: denominator, Price: price} + if err := assetPair.Validate(); err != nil { + panic(err) + } + return CurrentTWAP{PairID: assetPair.String(), Numerator: numerator, Denominator: denominator, Price: price} } diff --git a/x/vpool/types/pool_test.go b/x/vpool/types/pool_test.go index c9de5df05..fad0d8853 100644 --- a/x/vpool/types/pool_test.go +++ b/x/vpool/types/pool_test.go @@ -10,7 +10,7 @@ import ( ) func TestPoolHasEnoughQuoteReserve(t *testing.T) { - pair, err := common.NewAssetPairFromStr("BTC:NUSD") + pair, err := common.NewAssetPair("BTC:NUSD") require.NoError(t, err) pool := NewPool( @@ -33,7 +33,7 @@ func TestPoolHasEnoughQuoteReserve(t *testing.T) { } func TestGetBaseAmountByQuoteAmount(t *testing.T) { - pair, err := common.NewAssetPairFromStr("BTC:NUSD") + pair, err := common.NewAssetPair("BTC:NUSD") require.NoError(t, err) tests := []struct { @@ -106,7 +106,7 @@ func TestGetBaseAmountByQuoteAmount(t *testing.T) { } func TestGetQuoteAmountByBaseAmount(t *testing.T) { - pair, err := common.NewAssetPairFromStr("BTC:NUSD") + pair, err := common.NewAssetPair("BTC:NUSD") require.NoError(t, err) tests := []struct { @@ -179,7 +179,7 @@ func TestGetQuoteAmountByBaseAmount(t *testing.T) { } func TestIncreaseDecreaseReserves(t *testing.T) { - pair, err := common.NewAssetPairFromStr("ATOM:NUSD") + pair, err := common.NewAssetPair("ATOM:NUSD") require.NoError(t, err) pool := NewPool(