diff --git a/launch b/launch new file mode 160000 index 00000000..838f598b --- /dev/null +++ b/launch @@ -0,0 +1 @@ +Subproject commit 838f598b8196150232bacaffb93ea2af024aba5f diff --git a/localnet/val1/config/app.toml b/localnet/val1/config/app.toml new file mode 100644 index 00000000..5f793543 --- /dev/null +++ b/localnet/val1/config/app.toml @@ -0,0 +1,207 @@ +# This is a TOML config file. +# For more information, see https://github.com/toml-lang/toml + +############################################################################### +### Base Configuration ### +############################################################################### + +# The minimum gas prices a validator is willing to accept for processing a +# transaction. A transaction's fees must meet the minimum of any denomination +# specified in this config (e.g. 0.25token1;0.0001token2). +minimum-gas-prices = "0stake" + +# default: the last 100 states are kept in addition to every 500th state; pruning at 10 block intervals +# nothing: all historic states will be saved, nothing will be deleted (i.e. archiving node) +# everything: all saved states will be deleted, storing only the current and previous state; pruning at 10 block intervals +# custom: allow pruning options to be manually specified through 'pruning-keep-recent', 'pruning-keep-every', and 'pruning-interval' +pruning = "default" + +# These are applied if and only if the pruning strategy is custom. +pruning-keep-recent = "0" +pruning-keep-every = "0" +pruning-interval = "0" + +# HaltHeight contains a non-zero block height at which a node will gracefully +# halt and shutdown that can be used to assist upgrades and testing. +# +# Note: Commitment of state will be attempted on the corresponding block. +halt-height = 0 + +# HaltTime contains a non-zero minimum block time (in Unix seconds) at which +# a node will gracefully halt and shutdown that can be used to assist upgrades +# and testing. +# +# Note: Commitment of state will be attempted on the corresponding block. +halt-time = 0 + +# MinRetainBlocks defines the minimum block height offset from the current +# block being committed, such that all blocks past this offset are pruned +# from Tendermint. It is used as part of the process of determining the +# ResponseCommit.RetainHeight value during ABCI Commit. A value of 0 indicates +# that no blocks should be pruned. +# +# This configuration value is only responsible for pruning Tendermint blocks. +# It has no bearing on application state pruning which is determined by the +# "pruning-*" configurations. +# +# Note: Tendermint block pruning is dependant on this parameter in conunction +# with the unbonding (safety threshold) period, state pruning and state sync +# snapshot parameters to determine the correct minimum value of +# ResponseCommit.RetainHeight. +min-retain-blocks = 0 + +# InterBlockCache enables inter-block caching. +inter-block-cache = true + +# IndexEvents defines the set of events in the form {eventType}.{attributeKey}, +# which informs Tendermint what to index. If empty, all events will be indexed. +# +# Example: +# ["message.sender", "message.recipient"] +index-events = [] + +# IavlCacheSize set the size of the iavl tree cache. +# Default cache size is 50mb. +iavl-cache-size = 781250 + +# IAVLDisableFastNode enables or disables the fast node feature of IAVL. +# Default is true. +iavl-disable-fastnode = true + +############################################################################### +### Telemetry Configuration ### +############################################################################### + +[telemetry] + +# Prefixed with keys to separate services. +service-name = "" + +# Enabled enables the application telemetry functionality. When enabled, +# an in-memory sink is also enabled by default. Operators may also enabled +# other sinks such as Prometheus. +enabled = false + +# Enable prefixing gauge values with hostname. +enable-hostname = false + +# Enable adding hostname to labels. +enable-hostname-label = false + +# Enable adding service to labels. +enable-service-label = false + +# PrometheusRetentionTime, when positive, enables a Prometheus metrics sink. +prometheus-retention-time = 0 + +# GlobalLabels defines a global set of name/value label tuples applied to all +# metrics emitted using the wrapper functions defined in telemetry package. +# +# Example: +# [["chain_id", "cosmoshub-1"]] +global-labels = [ +] + +############################################################################### +### API Configuration ### +############################################################################### + +[api] + +# Enable defines if the API server should be enabled. +enable = false + +# Swagger defines if swagger documentation should automatically be registered. +swagger = false + +# Address defines the API server to listen on. +address = "tcp://0.0.0.0:1317" + +# MaxOpenConnections defines the number of maximum open connections. +max-open-connections = 1000 + +# RPCReadTimeout defines the Tendermint RPC read timeout (in seconds). +rpc-read-timeout = 10 + +# RPCWriteTimeout defines the Tendermint RPC write timeout (in seconds). +rpc-write-timeout = 0 + +# RPCMaxBodyBytes defines the Tendermint maximum response body (in bytes). +rpc-max-body-bytes = 1000000 + +# EnableUnsafeCORS defines if CORS should be enabled (unsafe - use it at your own risk). +enabled-unsafe-cors = false + +############################################################################### +### Rosetta Configuration ### +############################################################################### + +[rosetta] + +# Enable defines if the Rosetta API server should be enabled. +enable = false + +# Address defines the Rosetta API server to listen on. +address = ":8080" + +# Network defines the name of the blockchain that will be returned by Rosetta. +blockchain = "app" + +# Network defines the name of the network that will be returned by Rosetta. +network = "network" + +# Retries defines the number of retries when connecting to the node before failing. +retries = 3 + +# Offline defines if Rosetta server should run in offline mode. +offline = false + +############################################################################### +### gRPC Configuration ### +############################################################################### + +[grpc] + +# Enable defines if the gRPC server should be enabled. +enable = true + +# Address defines the gRPC server address to bind to. +address = "0.0.0.0:9090" + +############################################################################### +### gRPC Web Configuration ### +############################################################################### + +[grpc-web] + +# GRPCWebEnable defines if the gRPC-web should be enabled. +# NOTE: gRPC must also be enabled, otherwise, this configuration is a no-op. +enable = true + +# Address defines the gRPC-web server address to bind to. +address = "0.0.0.0:9091" + +# EnableUnsafeCORS defines if CORS should be enabled (unsafe - use it at your own risk). +enable-unsafe-cors = false + +############################################################################### +### State Sync Configuration ### +############################################################################### + +# State sync snapshots allow other nodes to rapidly join the network without replaying historical +# blocks, instead downloading and applying a snapshot of the application state at a given height. +[state-sync] + +# snapshot-interval specifies the block interval at which local state sync snapshots are +# taken (0 to disable). Must be a multiple of pruning-keep-every. +snapshot-interval = 0 + +# snapshot-keep-recent specifies the number of recent snapshots to keep and serve (0 to keep all). +snapshot-keep-recent = 2 + +[wasm] +# This is the maximum sdk gas (wasm and storage) that we allow for any x/wasm "smart" queries +query_gas_limit = 300000 +# This is the number of wasm vm instances we keep cached in memory for speed-up +# Warning: this is currently unstable and may lead to crashes, best to keep for 0 unless testing locally +lru_size = 0 \ No newline at end of file diff --git a/localnet/val1/config/client.toml b/localnet/val1/config/client.toml new file mode 100644 index 00000000..222695a3 --- /dev/null +++ b/localnet/val1/config/client.toml @@ -0,0 +1,17 @@ +# This is a TOML config file. +# For more information, see https://github.com/toml-lang/toml + +############################################################################### +### Client Configuration ### +############################################################################### + +# The network chain ID +chain-id = "" +# The keyring's backend, where the keys are stored (os|file|kwallet|pass|test|memory) +keyring-backend = "os" +# CLI output format (text|json) +output = "text" +# : to Tendermint RPC interface for this chain +node = "tcp://localhost:26657" +# Transaction broadcasting mode (sync|async|block) +broadcast-mode = "sync" diff --git a/localnet/val1/config/config.toml b/localnet/val1/config/config.toml new file mode 100644 index 00000000..0d635def --- /dev/null +++ b/localnet/val1/config/config.toml @@ -0,0 +1,466 @@ +# This is a TOML config file. +# For more information, see https://github.com/toml-lang/toml + +# NOTE: Any path below can be absolute (e.g. "/var/myawesomeapp/data") or +# relative to the home directory (e.g. "data"). The home directory is +# "$HOME/.tendermint" by default, but could be changed via $TMHOME env variable +# or --home cmd flag. + +####################################################################### +### Main Base Config Options ### +####################################################################### + +# TCP or UNIX socket address of the ABCI application, +# or the name of an ABCI application compiled in with the Tendermint binary +proxy_app = "tcp://127.0.0.1:26658" + +# A custom human readable name for this node +moniker = "Jeonghos-MacBook-Pro-16inch.local" + +# If this node is many blocks behind the tip of the chain, FastSync +# allows them to catchup quickly by downloading blocks in parallel +# and verifying their commits +fast_sync = true + +# Database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb +# * goleveldb (github.com/syndtr/goleveldb - most popular implementation) +# - pure go +# - stable +# * cleveldb (uses levigo wrapper) +# - fast +# - requires gcc +# - use cleveldb build tag (go build -tags cleveldb) +# * boltdb (uses etcd's fork of bolt - github.com/etcd-io/bbolt) +# - EXPERIMENTAL +# - may be faster is some use-cases (random reads - indexer) +# - use boltdb build tag (go build -tags boltdb) +# * rocksdb (uses github.com/tecbot/gorocksdb) +# - EXPERIMENTAL +# - requires gcc +# - use rocksdb build tag (go build -tags rocksdb) +# * badgerdb (uses github.com/dgraph-io/badger) +# - EXPERIMENTAL +# - use badgerdb build tag (go build -tags badgerdb) +db_backend = "goleveldb" + +# Database directory +db_dir = "data" + +# Output level for logging, including package level options +log_level = "info" + +# Output format: 'plain' (colored text) or 'json' +log_format = "plain" + +##### additional base config options ##### + +# Path to the JSON file containing the initial validator set and other meta data +genesis_file = "config/genesis.json" + +# Path to the JSON file containing the private key to use as a validator in the consensus protocol +priv_validator_key_file = "config/priv_validator_key.json" + +# Path to the JSON file containing the last sign state of a validator +priv_validator_state_file = "data/priv_validator_state.json" + +# TCP or UNIX socket address for Tendermint to listen on for +# connections from an external PrivValidator process +priv_validator_laddr = "" + +# Path to the JSON file containing the private key to use for node authentication in the p2p protocol +node_key_file = "config/node_key.json" + +# Mechanism to connect to the ABCI application: socket | grpc +abci = "socket" + +# If true, query the ABCI app on connecting to a new peer +# so the app can decide if we should keep the connection or not +filter_peers = false + + +####################################################################### +### Advanced Configuration Options ### +####################################################################### + +####################################################### +### RPC Server Configuration Options ### +####################################################### +[rpc] + +# TCP or UNIX socket address for the RPC server to listen on +laddr = "tcp://127.0.0.1:26657" + +# A list of origins a cross-domain request can be executed from +# Default value '[]' disables cors support +# Use '["*"]' to allow any origin +cors_allowed_origins = [] + +# A list of methods the client is allowed to use with cross-domain requests +cors_allowed_methods = ["HEAD", "GET", "POST", ] + +# A list of non simple headers the client is allowed to use with cross-domain requests +cors_allowed_headers = ["Origin", "Accept", "Content-Type", "X-Requested-With", "X-Server-Time", ] + +# TCP or UNIX socket address for the gRPC server to listen on +# NOTE: This server only supports /broadcast_tx_commit +grpc_laddr = "" + +# Maximum number of simultaneous connections. +# Does not include RPC (HTTP&WebSocket) connections. See max_open_connections +# If you want to accept a larger number than the default, make sure +# you increase your OS limits. +# 0 - unlimited. +# Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files} +# 1024 - 40 - 10 - 50 = 924 = ~900 +grpc_max_open_connections = 900 + +# Activate unsafe RPC commands like /dial_seeds and /unsafe_flush_mempool +unsafe = false + +# Maximum number of simultaneous connections (including WebSocket). +# Does not include gRPC connections. See grpc_max_open_connections +# If you want to accept a larger number than the default, make sure +# you increase your OS limits. +# 0 - unlimited. +# Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files} +# 1024 - 40 - 10 - 50 = 924 = ~900 +max_open_connections = 900 + +# Maximum number of unique clientIDs that can /subscribe +# If you're using /broadcast_tx_commit, set to the estimated maximum number +# of broadcast_tx_commit calls per block. +max_subscription_clients = 100 + +# Maximum number of unique queries a given client can /subscribe to +# If you're using GRPC (or Local RPC client) and /broadcast_tx_commit, set to +# the estimated # maximum number of broadcast_tx_commit calls per block. +max_subscriptions_per_client = 5 + +# Experimental parameter to specify the maximum number of events a node will +# buffer, per subscription, before returning an error and closing the +# subscription. Must be set to at least 100, but higher values will accommodate +# higher event throughput rates (and will use more memory). +experimental_subscription_buffer_size = 200 + +# Experimental parameter to specify the maximum number of RPC responses that +# can be buffered per WebSocket client. If clients cannot read from the +# WebSocket endpoint fast enough, they will be disconnected, so increasing this +# parameter may reduce the chances of them being disconnected (but will cause +# the node to use more memory). +# +# Must be at least the same as "experimental_subscription_buffer_size", +# otherwise connections could be dropped unnecessarily. This value should +# ideally be somewhat higher than "experimental_subscription_buffer_size" to +# accommodate non-subscription-related RPC responses. +experimental_websocket_write_buffer_size = 200 + +# If a WebSocket client cannot read fast enough, at present we may +# silently drop events instead of generating an error or disconnecting the +# client. +# +# Enabling this experimental parameter will cause the WebSocket connection to +# be closed instead if it cannot read fast enough, allowing for greater +# predictability in subscription behaviour. +experimental_close_on_slow_client = false + +# How long to wait for a tx to be committed during /broadcast_tx_commit. +# WARNING: Using a value larger than 10s will result in increasing the +# global HTTP write timeout, which applies to all connections and endpoints. +# See https://github.com/tendermint/tendermint/issues/3435 +timeout_broadcast_tx_commit = "10s" + +# Maximum size of request body, in bytes +max_body_bytes = 1000000 + +# Maximum size of request header, in bytes +max_header_bytes = 1048576 + +# The path to a file containing certificate that is used to create the HTTPS server. +# Might be either absolute path or path related to Tendermint's config directory. +# If the certificate is signed by a certificate authority, +# the certFile should be the concatenation of the server's certificate, any intermediates, +# and the CA's certificate. +# NOTE: both tls_cert_file and tls_key_file must be present for Tendermint to create HTTPS server. +# Otherwise, HTTP server is run. +tls_cert_file = "" + +# The path to a file containing matching private key that is used to create the HTTPS server. +# Might be either absolute path or path related to Tendermint's config directory. +# NOTE: both tls-cert-file and tls-key-file must be present for Tendermint to create HTTPS server. +# Otherwise, HTTP server is run. +tls_key_file = "" + +# pprof listen address (https://golang.org/pkg/net/http/pprof) +pprof_laddr = "localhost:6060" + +####################################################### +### P2P Configuration Options ### +####################################################### +[p2p] + +# Address to listen for incoming connections +laddr = "tcp://0.0.0.0:26656" + +# Address to advertise to peers for them to dial +# If empty, will use the same port as the laddr, +# and will introspect on the listener or use UPnP +# to figure out the address. ip and port are required +# example: 159.89.10.97:26656 +external_address = "" + +# Comma separated list of seed nodes to connect to +seeds = "" + +# Comma separated list of nodes to keep persistent connections to +persistent_peers = "" + +# UPNP port forwarding +upnp = false + +# Path to address book +addr_book_file = "config/addrbook.json" + +# Set true for strict address routability rules +# Set false for private or local networks +addr_book_strict = true + +# Maximum number of inbound peers +max_num_inbound_peers = 40 + +# Maximum number of outbound peers to connect to, excluding persistent peers +max_num_outbound_peers = 10 + +# List of node IDs, to which a connection will be (re)established ignoring any existing limits +unconditional_peer_ids = "" + +# Maximum pause when redialing a persistent peer (if zero, exponential backoff is used) +persistent_peers_max_dial_period = "0s" + +# Time to wait before flushing messages out on the connection +flush_throttle_timeout = "100ms" + +# Maximum size of a message packet payload, in bytes +max_packet_msg_payload_size = 1024 + +# Rate at which packets can be sent, in bytes/second +send_rate = 5120000 + +# Rate at which packets can be received, in bytes/second +recv_rate = 5120000 + +# Set true to enable the peer-exchange reactor +pex = true + +# Seed mode, in which node constantly crawls the network and looks for +# peers. If another node asks it for addresses, it responds and disconnects. +# +# Does not work if the peer-exchange reactor is disabled. +seed_mode = false + +# Comma separated list of peer IDs to keep private (will not be gossiped to other peers) +private_peer_ids = "" + +# Toggle to disable guard against peers connecting from the same ip. +allow_duplicate_ip = false + +# Peer connection configuration. +handshake_timeout = "20s" +dial_timeout = "3s" + +####################################################### +### Mempool Configuration Option ### +####################################################### +[mempool] + +# Mempool version to use: +# 1) "v0" - (default) FIFO mempool. +# 2) "v1" - prioritized mempool. +version = "v0" + +recheck = true +broadcast = true +wal_dir = "" + +# Maximum number of transactions in the mempool +size = 5000 + +# Limit the total size of all txs in the mempool. +# This only accounts for raw transactions (e.g. given 1MB transactions and +# max_txs_bytes=5MB, mempool will only accept 5 transactions). +max_txs_bytes = 1073741824 + +# Size of the cache (used to filter transactions we saw earlier) in transactions +cache_size = 10000 + +# Do not remove invalid transactions from the cache (default: false) +# Set to true if it's not possible for any invalid transaction to become valid +# again in the future. +keep-invalid-txs-in-cache = false + +# Maximum size of a single transaction. +# NOTE: the max size of a tx transmitted over the network is {max_tx_bytes}. +max_tx_bytes = 1048576 + +# Maximum size of a batch of transactions to send to a peer +# Including space needed by encoding (one varint per transaction). +# XXX: Unused due to https://github.com/tendermint/tendermint/issues/5796 +max_batch_bytes = 0 + +# ttl-duration, if non-zero, defines the maximum amount of time a transaction +# can exist for in the mempool. +# +# Note, if ttl-num-blocks is also defined, a transaction will be removed if it +# has existed in the mempool at least ttl-num-blocks number of blocks or if it's +# insertion time into the mempool is beyond ttl-duration. +ttl-duration = "0s" + +# ttl-num-blocks, if non-zero, defines the maximum number of blocks a transaction +# can exist for in the mempool. +# +# Note, if ttl-duration is also defined, a transaction will be removed if it +# has existed in the mempool at least ttl-num-blocks number of blocks or if +# it's insertion time into the mempool is beyond ttl-duration. +ttl-num-blocks = 0 + +####################################################### +### State Sync Configuration Options ### +####################################################### +[statesync] +# State sync rapidly bootstraps a new node by discovering, fetching, and restoring a state machine +# snapshot from peers instead of fetching and replaying historical blocks. Requires some peers in +# the network to take and serve state machine snapshots. State sync is not attempted if the node +# has any local state (LastBlockHeight > 0). The node will have a truncated block history, +# starting from the height of the snapshot. +enable = false + +# RPC servers (comma-separated) for light client verification of the synced state machine and +# retrieval of state data for node bootstrapping. Also needs a trusted height and corresponding +# header hash obtained from a trusted source, and a period during which validators can be trusted. +# +# For Cosmos SDK-based chains, trust_period should usually be about 2/3 of the unbonding time (~2 +# weeks) during which they can be financially punished (slashed) for misbehavior. +rpc_servers = "" +trust_height = 0 +trust_hash = "" +trust_period = "168h0m0s" + +# Time to spend discovering snapshots before initiating a restore. +discovery_time = "15s" + +# Temporary directory for state sync snapshot chunks, defaults to the OS tempdir (typically /tmp). +# Will create a new, randomly named directory within, and remove it when done. +temp_dir = "" + +# The timeout duration before re-requesting a chunk, possibly from a different +# peer (default: 1 minute). +chunk_request_timeout = "10s" + +# The number of concurrent chunk fetchers to run (default: 1). +chunk_fetchers = "4" + +####################################################### +### Fast Sync Configuration Connections ### +####################################################### +[fastsync] + +# Fast Sync version to use: +# 1) "v0" (default) - the legacy fast sync implementation +# 2) "v1" - refactor of v0 version for better testability +# 2) "v2" - complete redesign of v0, optimized for testability & readability +version = "v0" + +####################################################### +### Consensus Configuration Options ### +####################################################### +[consensus] + +wal_file = "data/cs.wal/wal" + +# How long we wait for a proposal block before prevoting nil +timeout_propose = "3s" +# How much timeout_propose increases with each round +timeout_propose_delta = "500ms" +# How long we wait after receiving +2/3 prevotes for “anything” (ie. not a single block or nil) +timeout_prevote = "1s" +# How much the timeout_prevote increases with each round +timeout_prevote_delta = "500ms" +# How long we wait after receiving +2/3 precommits for “anything” (ie. not a single block or nil) +timeout_precommit = "1s" +# How much the timeout_precommit increases with each round +timeout_precommit_delta = "500ms" +# How long we wait after committing a block, before starting on the new +# height (this gives us a chance to receive some more precommits, even +# though we already have +2/3). +timeout_commit = "5s" + +# How many blocks to look back to check existence of the node's consensus votes before joining consensus +# When non-zero, the node will panic upon restart +# if the same consensus key was used to sign {double_sign_check_height} last blocks. +# So, validators should stop the state machine, wait for some blocks, and then restart the state machine to avoid panic. +double_sign_check_height = 0 + +# Make progress as soon as we have all the precommits (as if TimeoutCommit = 0) +skip_timeout_commit = false + +# EmptyBlocks mode and possible interval between empty blocks +create_empty_blocks = true +create_empty_blocks_interval = "0s" + +# Reactor sleep duration parameters +peer_gossip_sleep_duration = "100ms" +peer_query_maj23_sleep_duration = "2s" + +####################################################### +### Storage Configuration Options ### +####################################################### +[storage] + +# Set to true to discard ABCI responses from the state store, which can save a +# considerable amount of disk space. Set to false to ensure ABCI responses are +# persisted. ABCI responses are required for /block_results RPC queries, and to +# reindex events in the command-line tool. +discard_abci_responses = false + +####################################################### +### Transaction Indexer Configuration Options ### +####################################################### +[tx_index] + +# What indexer to use for transactions +# +# The application will set which txs to index. In some cases a node operator will be able +# to decide which txs to index based on configuration set in the application. +# +# Options: +# 1) "null" +# 2) "kv" (default) - the simplest possible indexer, backed by key-value storage (defaults to levelDB; see DBBackend). +# - When "kv" is chosen "tx.height" and "tx.hash" will always be indexed. +# 3) "psql" - the indexer services backed by PostgreSQL. +# When "kv" or "psql" is chosen "tx.height" and "tx.hash" will always be indexed. +indexer = "kv" + +# The PostgreSQL connection configuration, the connection format: +# postgresql://:@:/? +psql-conn = "" + +####################################################### +### Instrumentation Configuration Options ### +####################################################### +[instrumentation] + +# When true, Prometheus metrics are served under /metrics on +# PrometheusListenAddr. +# Check out the documentation for the list of available metrics. +prometheus = false + +# Address to listen for Prometheus collector(s) connections +prometheus_listen_addr = ":26660" + +# Maximum number of simultaneous connections. +# If you want to accept a larger number than the default, make sure +# you increase your OS limits. +# 0 - unlimited. +max_open_connections = 3 + +# Instrumentation namespace +namespace = "tendermint" diff --git a/x/amm/keeper/farming_test.go b/x/amm/keeper/farming_test.go index fb5a2966..00e4ee44 100644 --- a/x/amm/keeper/farming_test.go +++ b/x/amm/keeper/farming_test.go @@ -195,12 +195,13 @@ func (s *KeeperTestSuite) TestFarming() { _, pool := s.CreateMarketAndPool("ucre", "uusd", utils.ParseDec("5")) lpAddr1 := s.FundedAccount(1, utils.ParseCoins("10000_000000ucre,10000_000000uusd")) lpAddr2 := s.FundedAccount(2, utils.ParseCoins("10000_000000ucre,10000_000000uusd")) - position1, liquidity1, _ := s.AddLiquidity( + position1, _, _ := s.AddLiquidity( lpAddr1, pool.Id, utils.ParseDec("4"), utils.ParseDec("6"), utils.ParseCoins("100_000000ucre,500_000000uusd")) - position2, liquidity2, _ := s.AddLiquidity( + position2, _, _ := s.AddLiquidity( lpAddr2, pool.Id, utils.ParseDec("4.8"), utils.ParseDec("5.2"), utils.ParseCoins("100_000000ucre,500_000000uusd")) + s.AssertEqual(sdk.NewInt(2118033988), liquidity1) s.AssertEqual(sdk.NewInt(11067395518), liquidity2) diff --git a/x/amm/keeper/position_test.go b/x/amm/keeper/position_test.go index 5e08509e..978a46dc 100644 --- a/x/amm/keeper/position_test.go +++ b/x/amm/keeper/position_test.go @@ -220,8 +220,8 @@ func (s *KeeperTestSuite) TestReinitializePosition() { s.RemoveLiquidity(ownerAddr, position.Id, liquidity) position, _ = s.keeper.GetPosition(s.Ctx, position.Id) - s.AssertEqual(sdk.NewInt(0), position.Liquidity) + s.AssertEqual(sdk.NewInt(0), position.Liquidity) s.AddLiquidity( ownerAddr, pool.Id, lowerPrice, upperPrice, desiredAmt) } diff --git a/x/amm/keeper/sim_test.go b/x/amm/keeper/sim_test.go index 8c9e9d0f..68071af6 100644 --- a/x/amm/keeper/sim_test.go +++ b/x/amm/keeper/sim_test.go @@ -6,6 +6,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" utils "github.com/crescent-network/crescent/v5/types" + "github.com/crescent-network/crescent/v5/x/amm/keeper" "github.com/crescent-network/crescent/v5/x/amm/types" exchangetypes "github.com/crescent-network/crescent/v5/x/exchange/types" ) @@ -97,6 +98,104 @@ func (s *KeeperTestSuite) TestSimulation() { qty := utils.RandomInt(r, sdk.NewInt(10000), sdk.NewInt(10_000000)) s.PlaceMarketOrder(market.Id, ordererAddr, isBuy, qty) + _, broken := keeper.CanRemoveLiquidityInvariant(s.keeper)(s.Ctx) + s.Require().False(broken) + + s.NextBlock() + } + } +} + +func (s *KeeperTestSuite) TestSimulation_Batch() { + minPrice, maxPrice := utils.ParseDec("0.000001"), utils.ParseDec("100000") + enoughCoins := utils.ParseCoins("1000000000000000000000000000000ucre,1000000000000000000000000000000uusd") + for seed := int64(1); seed <= 5; seed++ { + s.SetupTest() + + r := rand.New(rand.NewSource(seed)) + var initialPrice sdk.Dec + v := r.Float64() + switch { + case v <= 0.3: + initialPrice = utils.RandomDec(r, minPrice, utils.ParseDec("0.000001")) + case v <= 0.7: + initialPrice = utils.RandomDec(r, utils.ParseDec("0.05"), utils.ParseDec("500")) + default: + initialPrice = utils.RandomDec(r, utils.ParseDec("100000"), maxPrice) + } + market, pool := s.CreateMarketAndPool("ucre", "uusd", initialPrice) + marketState := s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id) + lastPrice := exchangetypes.PriceAtTick(exchangetypes.TickAtPrice(initialPrice)) + marketState.LastPrice = &lastPrice + s.App.ExchangeKeeper.SetMarketState(s.Ctx, market.Id, marketState) + + lpAddrs := make([]sdk.AccAddress, 10) + for i := range lpAddrs { + lpAddrs[i] = s.FundedAccount(1+i, enoughCoins) + } + ordererAddr := s.FundedAccount(100, enoughCoins) + + for i := 0; i < 100; i++ { + poolState := s.keeper.MustGetPoolState(s.Ctx, pool.Id) + + // Randomly add liquidity + for _, lpAddr := range lpAddrs { + if r.Float64() <= 0.3 { + var lowerPrice, upperPrice sdk.Dec + var desiredAmt sdk.Coins + v := r.Float64() + currentPrice := poolState.CurrentSqrtPrice.Power(2).Dec() + switch { + case v <= 0.3: // lowerPrice < upperPrice <= poolPrice + lowerPrice = utils.RandomDec(r, minPrice, currentPrice.Mul(utils.ParseDec("0.8"))) + upperPrice = utils.RandomDec(r, lowerPrice.Mul(utils.ParseDec("1.001")), currentPrice) + case v <= 0.7: // lowerPrice < poolPrice <= upperPrice + lowerPrice = utils.RandomDec(r, minPrice, currentPrice) + upperPrice = utils.RandomDec(r, currentPrice, maxPrice) + default: // poolPrice <= lowerPrice < upperPrice + lowerPrice = utils.RandomDec(r, currentPrice, maxPrice.Mul(utils.ParseDec("0.8"))) + upperPrice = utils.RandomDec(r, lowerPrice.Mul(utils.ParseDec("1.001")), maxPrice) + } + lowerPrice = exchangetypes.PriceAtTick(types.AdjustTickToTickSpacing( + exchangetypes.TickAtPrice(lowerPrice), pool.TickSpacing, false)) + upperPrice = exchangetypes.PriceAtTick(types.AdjustTickToTickSpacing( + exchangetypes.TickAtPrice(upperPrice), pool.TickSpacing, true)) + if upperPrice.LTE(currentPrice) { + desiredAmt = sdk.NewCoins(sdk.NewCoin("uusd", utils.RandomInt(r, sdk.NewInt(10000), sdk.NewInt(1000_000000)))) + } else if lowerPrice.GTE(currentPrice) { + desiredAmt = sdk.NewCoins(sdk.NewCoin("ucre", utils.RandomInt(r, sdk.NewInt(10000), sdk.NewInt(1000_000000)))) + } else { + desiredAmt = utils.ParseCoins("1000_000000ucre,1000_000000uusd") + } + s.AddLiquidity(lpAddr, pool.Id, lowerPrice, upperPrice, desiredAmt) + } + } + + // Randomly remove liquidity + for _, lpAddr := range lpAddrs { + if r.Float64() <= 0.2 { + var positions []types.Position + s.keeper.IteratePositionsByOwner(s.Ctx, lpAddr, func(position types.Position) (stop bool) { + positions = append(positions, position) + return false + }) + if len(positions) == 0 { + continue + } + position := positions[r.Intn(len(positions))] + liquidity := utils.RandomInt(r, utils.ZeroInt, position.Liquidity).Add(sdk.NewInt(1)) + s.RemoveLiquidity(lpAddr, position.Id, liquidity) + } + } + + // Randomly place market orders + isBuy := r.Float64() <= 0.5 + qty := utils.RandomInt(r, sdk.NewInt(10000), sdk.NewInt(10_000000)) + s.PlaceMarketOrder(market.Id, ordererAddr, isBuy, qty) + + _, broken := keeper.CanRemoveLiquidityInvariant(s.keeper)(s.Ctx) + s.Require().False(broken) + s.NextBlock() } } diff --git a/x/amm/keeper/source_test.go b/x/amm/keeper/source_test.go index 0ab39192..26f26c3c 100644 --- a/x/amm/keeper/source_test.go +++ b/x/amm/keeper/source_test.go @@ -2,11 +2,13 @@ package keeper_test import ( "math/rand" + "time" sdk "github.com/cosmos/cosmos-sdk/types" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" utils "github.com/crescent-network/crescent/v5/types" + "github.com/crescent-network/crescent/v5/x/amm/keeper" "github.com/crescent-network/crescent/v5/x/amm/types" exchangetypes "github.com/crescent-network/crescent/v5/x/exchange/types" ) @@ -72,13 +74,39 @@ func (s *KeeperTestSuite) TestPoolOrdersMatching_FindEdgecase() { } for j := 0; j < 300; j++ { // Execute 300 random market orders - isBuy := r.Float64() < 0.5 - qty := randInt(r, sdk.NewInt(10000), sdk.NewInt(5_000000)) - s.PlaceMarketOrder(market.Id, ordererAddr, isBuy, qty) + for k := 0; k < 10; k++ { // Execute 10 random market orders per block + isBuy := r.Float64() < 0.5 + qty := randInt(r, sdk.NewInt(10000), sdk.NewInt(5_000000)) + + s.PlaceMarketOrder(market.Id, ordererAddr, isBuy, qty) + } + _, broken := keeper.CanRemoveLiquidityInvariant(s.keeper)(s.Ctx) + s.Require().False(broken) s.NextBlock() - } - } + + for k := 0; k < 10; k++ { // Execute 10 random market orders per block + isBuy := r.Float64() < 0.5 + + marketState := s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id) + lastPrice := *marketState.LastPrice + price := lastPrice + lower := sdk.MaxInt(sdk.NewInt(10000), sdk.NewInt(15000).ToDec().Quo(lastPrice).TruncateInt()) + qty := randInt(r, lower, sdk.NewInt(5_000000)) + + if isBuy { + price = lastPrice.Mul(utils.OneDec.Add(randDec(r, utils.ParseDec("0.001"), utils.ParseDec("0.09")))) + } else { + price = lastPrice.Mul(utils.OneDec.Sub(randDec(r, utils.ParseDec("0.001"), utils.ParseDec("0.09")))) + } + price = exchangetypes.RoundPrice(price) + s.PlaceBatchLimitOrder(market.Id, ordererAddr, isBuy, price, qty, time.Hour) + } + + s.Ctx = s.Ctx.WithEventManager(sdk.NewEventManager()) + s.Require().NoError(s.App.ExchangeKeeper.RunBatchMatching(s.Ctx, market)) + } // End of 300 random market orders + } // End of 5 different random seeds } func randInt(r *rand.Rand, min, max sdk.Int) sdk.Int { diff --git a/x/exchange/keeper/matching_test.go b/x/exchange/keeper/matching_test.go index f221aa86..b0e216d3 100644 --- a/x/exchange/keeper/matching_test.go +++ b/x/exchange/keeper/matching_test.go @@ -26,17 +26,18 @@ func (s *KeeperTestSuite) TestOrderSourceMatching() { s.AssertEqual(sdk.NewInt(5_000000), res.ExecutedQuantity) s.AssertEqual(utils.ParseCoin("5_000000ucre"), res.Paid) s.AssertEqual(utils.ParseCoin("503_485000uusd"), res.Received) + s.AssertEqual(utils.ParseDec("101"), *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) } func (s *KeeperTestSuite) TestOrderSourceMatchingAsMaker() { // Order book looks like: // | 2.7200 | // | 2.7100 | - // (os) ########## | 2.6080 | + // (os) ########## | 2.6080 | --> last price // (os) ###### | 2.6060 | // (os) ## | 2.5040 | // | 2.4020 | market order - // | 2.4010 | --> last price + // | 2.4010 | // | 2.4000 | os := types.NewMockOrderSource( "mockOrderSource", @@ -57,6 +58,9 @@ func (s *KeeperTestSuite) TestOrderSourceMatchingAsMaker() { ordererAddr := s.FundedAccount(2, enoughCoins) _, res := s.PlaceMarketOrder(market.Id, ordererAddr, true, sdk.NewInt(10_000001)) + + s.AssertEqual(utils.ParseDec("2.6080"), *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + s.AssertEqual(sdk.NewInt(10_000001), res.ExecutedQuantity) s.AssertEqual(utils.ParseCoin("25_860003uusd"), res.Paid) s.AssertEqual(utils.ParseCoin("9_970000ucre"), res.Received) @@ -109,6 +113,8 @@ func (s *KeeperTestSuite) TestMatchingByMaxPriceLimit() { expectedFee := sdk.Coins{} expectedOsBalancesDiff := sdk.Coins{} + s.AssertEqual(utils.ParseDec("2.1010"), *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + feeAmountAfterMatching := s.GetAllBalances(feeCollector) feeAmount := feeAmountAfterMatching.Sub(feeAmountBeforeMatching) s.AssertEqual(expectedFee, feeAmount) @@ -116,4 +122,516 @@ func (s *KeeperTestSuite) TestMatchingByMaxPriceLimit() { osBalanceAfterMatching := s.GetAllBalances(os.Address) osBalanceDiff, _ := osBalanceAfterMatching.SafeSub(osBalanceBeforeMatching) s.AssertEqual(expectedOsBalancesDiff, osBalanceDiff) + + _, _, _, err := s.App.ExchangeKeeper.PlaceLimitOrder(s.Ctx, market.Id, ordererAddr, true, utils.ParseDec("2.5040"), sdk.NewInt(2_000001), time.Hour) + s.Require().EqualError(err, "price is higher than the limit 2.311100000000000000: order price out of range") +} + +func (s *KeeperTestSuite) TestMatchingViaMaxPriceLimit() { + // Order book looks like: + // | 2.7200 | + // | 2.7100 | + // (os) ########## | 2.7080 | + // (os) ###### | 2.6010 | --> last price + // (os) ## | 2.5040 | + // | 2.4020 | market order + // | 2.4010 | + // | 2.1000 | + os := types.NewMockOrderSource( + "mockOrderSource", + types.NewMockOrderSourceOrder(false, utils.ParseDec("2.708"), sdk.NewInt(10_000000)), + types.NewMockOrderSourceOrder(false, utils.ParseDec("2.601"), sdk.NewInt(6_000000)), + types.NewMockOrderSourceOrder(false, utils.ParseDec("2.504"), sdk.NewInt(2_000000))) + s.FundAccount(os.Address, enoughCoins) + s.App.ExchangeKeeper = *s.App.ExchangeKeeper.SetOrderSources(os) + s.keeper = s.App.ExchangeKeeper + + market := s.CreateMarket("ucre", "uusd") + mmAddr := s.FundedAccount(1, enoughCoins) + s.MakeLastPrice(market.Id, mmAddr, utils.ParseDec("2.401")) + + feeCollector := market.MustGetFeeCollectorAddress() + feeAmountBeforeMatching := s.GetAllBalances(feeCollector) + osBalanceBeforeMatching := s.GetAllBalances(os.Address) + + ordererAddr := s.FundedAccount(2, enoughCoins) + _, res := s.PlaceMarketOrder(market.Id, ordererAddr, true, sdk.NewInt(10_000001)) + s.AssertEqual(sdk.NewInt(8_000000), res.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("20_614000uusd"), res.Paid) + s.AssertEqual(utils.ParseCoin("7_976000ucre"), res.Received) + expectedFee := sdk.Coins{utils.ParseCoin("12000ucre")} + expectedOsBalancDiff := sdk.Coins{sdk.Coin{Denom: "ucre", Amount: sdk.NewInt(-7988000)}, + utils.ParseCoin("20_614000uusd")} + + s.AssertEqual(utils.ParseDec("2.6010"), *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + + feeAmountAfterMatching := s.GetAllBalances(feeCollector) + feeAmount := feeAmountAfterMatching.Sub(feeAmountBeforeMatching) + s.AssertEqual(expectedFee, feeAmount) + osBalanceAfterMatching := s.GetAllBalances(os.Address) + osBalanceDiff, _ := osBalanceAfterMatching.SafeSub(osBalanceBeforeMatching) + s.AssertEqual(expectedOsBalancDiff, osBalanceDiff) +} + +func (s *KeeperTestSuite) TestOrderSourceMatchingAsMakerNearMaxPrice() { + // Order book looks like: + // (os) ###### | 10^24 | --> new last price + // (os) ## | 10^24-10^20 | + // | 10^24-2*10^20 | market order --> prev last price + + firstPrice := types.MaxPrice.Sub(sdk.NewDecFromInt(sdk.NewIntWithDecimal(1, 20))) + secondPrice := types.MaxPrice + os := types.NewMockOrderSource( + "mockOrderSource", + types.NewMockOrderSourceOrder(false, secondPrice, sdk.NewInt(6_000000_000000)), + types.NewMockOrderSourceOrder(false, firstPrice, sdk.NewInt(2_000000_000000))) + s.FundAccount(os.Address, enoughCoins) + s.App.ExchangeKeeper = *s.App.ExchangeKeeper.SetOrderSources(os) + s.keeper = s.App.ExchangeKeeper + + market := s.CreateMarket("ucre", "uusd") + mmAddr := s.FundedAccount(1, enoughCoins) + lastPrice := types.MaxPrice.Sub(sdk.NewDecFromInt(sdk.NewIntWithDecimal(1, 20))).Sub(sdk.NewDecFromInt(sdk.NewIntWithDecimal(1, 20))) + s.MakeLastPrice(market.Id, mmAddr, lastPrice) + + feeCollector := market.MustGetFeeCollectorAddress() + feeAmountBeforeMatching := s.GetAllBalances(feeCollector) + osBalanceBeforeMatching := s.GetAllBalances(os.Address) + + ordererAddr := s.FundedAccount(2, enoughCoins) + _, res := s.PlaceMarketOrder(market.Id, ordererAddr, true, sdk.NewInt(5_000000_000001)) + + s.AssertEqual(types.MaxPrice, *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + + s.AssertEqual(sdk.NewInt(5_000000_000001), res.ExecutedQuantity) + firstPaid := sdk.NewInt(2_000000_000000).ToDec().Mul(firstPrice).Ceil().TruncateInt() + secondPaid := sdk.NewInt(3_000000_000001).ToDec().Mul(secondPrice).Ceil().TruncateInt() + s.AssertEqual(firstPaid.Add(secondPaid), res.Paid.Amount) + s.AssertEqual(utils.ParseCoin("4_985000_000000ucre"), res.Received) + + feeAmountAfterMatching := s.GetAllBalances(feeCollector) + feeAmount := feeAmountAfterMatching.Sub(feeAmountBeforeMatching) + s.AssertEqual(utils.ParseCoins("7500_000001ucre"), feeAmount) + + osBalanceAfterMatching := s.GetAllBalances(os.Address) + osBalanceDiff, _ := osBalanceAfterMatching.SafeSub(osBalanceBeforeMatching) + expectedOsBalancesDiff := sdk.Coins{ + sdk.Coin{Denom: "ucre", Amount: sdk.NewInt(-4992500000001)}, + sdk.Coin{Denom: "uusd", Amount: firstPaid.Add(secondPaid)}} + s.AssertEqual(expectedOsBalancesDiff, osBalanceDiff) +} + +func (s *KeeperTestSuite) TestOrderSourceMatchingAsMakerNearMinPrice() { + // Order book looks like: + // market order #####.1 | 10^-14+2*10^-17 | --> prev. last price + // | 10^-14+10^-17 | ## (os) + // | 10^-14 | ###### (os) --> new last price + + firstPrice := types.MinPrice.Add(sdk.NewDecWithPrec(1, 17)) + secondPrice := types.MinPrice + + os := types.NewMockOrderSource( + "mockOrderSource", + types.NewMockOrderSourceOrder(true, secondPrice, sdk.NewInt(6000_00000_00000_00000)), + types.NewMockOrderSourceOrder(true, firstPrice, sdk.NewInt(2000_00000_00000_00000))) + s.FundAccount(os.Address, enoughCoins) + s.App.ExchangeKeeper = *s.App.ExchangeKeeper.SetOrderSources(os) + s.keeper = s.App.ExchangeKeeper + + market := s.CreateMarket("ucre", "uusd") + mmAddr := s.FundedAccount(1, enoughCoins) + lastPrice := types.MinPrice.Add(sdk.NewDecWithPrec(1, 17)).Add(sdk.NewDecWithPrec(1, 17)) + + // make last TestOrderSourceMatchingAsMakerNearMinPrice + s.PlaceLimitOrder(market.Id, mmAddr, true, lastPrice, sdk.NewInt(1000_00000_00000_00000), time.Hour) + s.PlaceLimitOrder(market.Id, mmAddr, false, lastPrice, sdk.NewInt(1000_00000_00000_00000), time.Hour) + + feeCollector := market.MustGetFeeCollectorAddress() + feeAmountBeforeMatching := s.GetAllBalances(feeCollector) + osBalanceBeforeMatching := s.GetAllBalances(os.Address) + + ordererAddr := s.FundedAccount(2, enoughCoins) + _, res := s.PlaceMarketOrder(market.Id, ordererAddr, false, sdk.NewInt(5000_00000_00000_00001)) + + s.AssertEqual(types.MinPrice, *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + + s.AssertEqual(sdk.NewInt(5000_00000_00000_00001), res.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("5000_00000_00000_00001ucre"), res.Paid) + s.AssertEqual(utils.ParseCoin("49869uusd"), res.Received) + + feeAmountAfterMatching := s.GetAllBalances(feeCollector) + feeAmount := feeAmountAfterMatching.Sub(feeAmountBeforeMatching) + s.AssertEqual(utils.ParseCoins("76uusd"), feeAmount) + + osBalanceAfterMatching := s.GetAllBalances(os.Address) + osBalanceDiff, _ := osBalanceAfterMatching.SafeSub(osBalanceBeforeMatching) + expectedOsBalancesDiff := sdk.Coins{ + sdk.Coin{Denom: "ucre", Amount: sdk.NewInt(5000_00000_00000_00001)}, + sdk.Coin{Denom: "uusd", Amount: sdk.NewInt(-49945)}} + s.AssertEqual(expectedOsBalancesDiff, osBalanceDiff) +} + +func (s *KeeperTestSuite) TestOrderSourceMatchingAsMakerNearMaxPriceWithMaxQty() { + // Order book looks like: + // (os) ########## | 10^24 | --> new last price + // (os) ######### | 10^24-10^20 | + // | 10^24-2*10^20 | market order --> prev last price + + firstPrice := types.MaxPrice.Sub(sdk.NewDecFromInt(sdk.NewIntWithDecimal(1, 20))) + secondPrice := types.MaxPrice + os := types.NewMockOrderSource( + "mockOrderSource", + types.NewMockOrderSourceOrder(false, secondPrice, sdk.NewIntWithDecimal(1, 30)), + types.NewMockOrderSourceOrder(false, firstPrice, sdk.NewIntWithDecimal(1, 29).Mul(sdk.NewInt(9)))) + s.FundAccount(os.Address, enoughCoins) + s.App.ExchangeKeeper = *s.App.ExchangeKeeper.SetOrderSources(os) + s.keeper = s.App.ExchangeKeeper + + market := s.CreateMarket("ucre", "uusd") + mmAddr := s.FundedAccount(1, enoughCoins) + lastPrice := types.MaxPrice.Sub(sdk.NewDecFromInt(sdk.NewIntWithDecimal(1, 20))).Sub(sdk.NewDecFromInt(sdk.NewIntWithDecimal(1, 20))) + s.MakeLastPrice(market.Id, mmAddr, lastPrice) + + feeCollector := market.MustGetFeeCollectorAddress() + feeAmountBeforeMatching := s.GetAllBalances(feeCollector) + osBalanceBeforeMatching := s.GetAllBalances(os.Address) + + ordererAddr := s.FundedAccount(2, enoughCoins) + _, res := s.PlaceMarketOrder(market.Id, ordererAddr, true, sdk.NewIntWithDecimal(1, 30)) + + s.AssertEqual(types.MaxPrice, *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + + s.AssertEqual(sdk.NewIntWithDecimal(1, 30), res.ExecutedQuantity) + firstPaid := sdk.NewIntWithDecimal(1, 29).Mul(sdk.NewInt(9)).ToDec().Mul(firstPrice).Ceil().TruncateInt() + secondPaid := sdk.NewIntWithDecimal(1, 29).ToDec().Mul(secondPrice).Ceil().TruncateInt() + s.AssertEqual(firstPaid.Add(secondPaid), res.Paid.Amount) + s.AssertEqual(sdk.NewIntWithDecimal(1, 30).Sub(sdk.NewIntWithDecimal(1, 27).Mul(sdk.NewInt(3))), res.Received.Amount) + + feeAmountAfterMatching := s.GetAllBalances(feeCollector) + feeAmount := feeAmountAfterMatching.Sub(feeAmountBeforeMatching) + s.AssertEqual(sdk.NewIntWithDecimal(1, 26).Mul(sdk.NewInt(15)), feeAmount.AmountOf("ucre")) + + osBalanceAfterMatching := s.GetAllBalances(os.Address) + osBalanceDiff, _ := osBalanceAfterMatching.SafeSub(osBalanceBeforeMatching) + expectedOsBalancesDiff := sdk.Coins{ + sdk.Coin{Denom: "ucre", Amount: sdk.NewIntWithDecimal(1, 30).Sub(sdk.NewIntWithDecimal(1, 26).Mul(sdk.NewInt(15))).Neg()}, + sdk.Coin{Denom: "uusd", Amount: firstPaid.Add(secondPaid)}} + s.AssertEqual(expectedOsBalancesDiff, osBalanceDiff) +} + +func (s *KeeperTestSuite) TestOrderSourceMatchingAsMakerNearMinPriceWithMinQty() { + // Order book looks like: + // market order #####.1 | 10^-14+2*10^-17 | --> prev. last price + // | 10^-14+10^-17 | # (os) + // | 10^-14 | ###### (os) --> new last price + + firstPrice := types.MinPrice.Add(sdk.NewDecWithPrec(1, 17)) + secondPrice := types.MinPrice + + os := types.NewMockOrderSource( + "mockOrderSource", + types.NewMockOrderSourceOrder(true, secondPrice, sdk.NewInt(60000)), + types.NewMockOrderSourceOrder(true, firstPrice, sdk.NewInt(10000))) + s.FundAccount(os.Address, enoughCoins) + s.App.ExchangeKeeper = *s.App.ExchangeKeeper.SetOrderSources(os) + s.keeper = s.App.ExchangeKeeper + + market := s.CreateMarket("ucre", "uusd") + mmAddr := s.FundedAccount(1, enoughCoins) + lastPrice := types.MinPrice.Add(sdk.NewDecWithPrec(1, 17)).Add(sdk.NewDecWithPrec(1, 17)) + + // make last TestOrderSourceMatchingAsMakerNearMinPrice + s.PlaceLimitOrder(market.Id, mmAddr, true, lastPrice, sdk.NewInt(1000_00000_00000_00000), time.Hour) + s.PlaceLimitOrder(market.Id, mmAddr, false, lastPrice, sdk.NewInt(1000_00000_00000_00000), time.Hour) + + feeCollector := market.MustGetFeeCollectorAddress() + feeAmountBeforeMatching := s.GetAllBalances(feeCollector) + osBalanceBeforeMatching := s.GetAllBalances(os.Address) + + ordererAddr := s.FundedAccount(2, enoughCoins) + _, res := s.PlaceMarketOrder(market.Id, ordererAddr, false, sdk.NewInt(50001)) + + s.AssertEqual(types.MinPrice, *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + + s.AssertEqual(sdk.NewInt(50001), res.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("50001ucre"), res.Paid) + s.AssertEqual(utils.ParseCoin("0uusd"), res.Received) + + feeAmountAfterMatching := s.GetAllBalances(feeCollector) + feeAmount := feeAmountAfterMatching.Sub(feeAmountBeforeMatching) + s.AssertEqual(utils.ParseCoins("1uusd"), feeAmount) + + osBalanceAfterMatching := s.GetAllBalances(os.Address) + osBalanceDiff, _ := osBalanceAfterMatching.SafeSub(osBalanceBeforeMatching) + expectedOsBalancesDiff := sdk.Coins{ + sdk.Coin{Denom: "ucre", Amount: sdk.NewInt(50001)}, + sdk.Coin{Denom: "uusd", Amount: sdk.NewInt(-1)}} + s.AssertEqual(expectedOsBalancesDiff, osBalanceDiff) +} + +func (s *KeeperTestSuite) TestOrderSourceMatchingAsTakerAndMaker() { + // Order book looks like: + // | 2.7200 | + // | 2.7100 | + // (os) ########## | 2.6080 | + // (os) ###### | 2.6060 | limit order --> new last price: taker + // | 2.5050 |--> prev. last price + // (os) ## | 2.5040 | + // | 2.4010 | + // | 2.4000 | + + market := s.CreateMarket("ucre", "uusd") + mmAddr := s.FundedAccount(1, enoughCoins) + s.MakeLastPrice(market.Id, mmAddr, utils.ParseDec("2.505")) + + feeCollector := market.MustGetFeeCollectorAddress() + feeAmountBeforeMatching := s.GetAllBalances(feeCollector) + + ordererAddr := s.FundedAccount(2, enoughCoins) + _, order, res := s.PlaceLimitOrder( + market.Id, ordererAddr, true, utils.ParseDec("2.6060"), sdk.NewInt(7_999999), time.Hour) + s.AssertEqual(utils.ParseDec("2.5050"), *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + + s.AssertEqual(sdk.ZeroInt(), res.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("0uusd"), res.Paid) + s.AssertEqual(utils.ParseCoin("0ucre"), res.Received) + + s.NextBlock() + + order, found := s.keeper.GetOrder(s.Ctx, order.Id) + s.Require().True(found) + + os := types.NewMockOrderSource( + "mockOrderSource", + types.NewMockOrderSourceOrder(false, utils.ParseDec("2.608"), sdk.NewInt(10_000000)), + types.NewMockOrderSourceOrder(false, utils.ParseDec("2.606"), sdk.NewInt(6_000000)), + types.NewMockOrderSourceOrder(false, utils.ParseDec("2.504"), sdk.NewInt(2_000000))) + s.FundAccount(os.Address, enoughCoins) + s.App.ExchangeKeeper = *s.App.ExchangeKeeper.SetOrderSources(os) + s.keeper = s.App.ExchangeKeeper + + osBalanceBeforeMatching := s.GetAllBalances(os.Address) + + s.Ctx = s.Ctx.WithEventManager(sdk.NewEventManager()) + s.Require().NoError(s.keeper.RunBatchMatching(s.Ctx, market)) + + ev := s.getEventOrderFilled(order.Id) + + s.AssertEqual(sdk.NewInt(7_999999), ev.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("20_645998uusd"), ev.Paid) + s.AssertEqual(utils.ParseCoin("7_975999ucre"), ev.Received) + + order, found = s.keeper.GetOrder(s.Ctx, order.Id) + s.Require().False(found) + + ev_os := s.getEventOrderSourceOrdersFilled("mockOrderSource") + s.AssertEqual(sdk.NewInt(7_999999), ev_os.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("20_645998uusd"), ev_os.Received) + s.AssertEqual(utils.ParseCoin("7_991000ucre"), ev_os.Paid) + + s.AssertEqual(utils.ParseDec("2.6060"), *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + + feeAmountAfterMatching := s.GetAllBalances(feeCollector) + feeAmount := feeAmountAfterMatching.Sub(feeAmountBeforeMatching) + s.AssertEqual(utils.ParseCoins("15001ucre"), feeAmount) + + osBalanceAfterMatching := s.GetAllBalances(os.Address) + osBalanceDiff, _ := osBalanceAfterMatching.SafeSub(osBalanceBeforeMatching) + expectedOsBalancesDiff := sdk.Coins{ + sdk.Coin{Denom: "ucre", Amount: sdk.NewInt(-7991000)}, + utils.ParseCoin("20_645998uusd")} + s.AssertEqual(expectedOsBalancesDiff, osBalanceDiff) +} + +func (s *KeeperTestSuite) TestOrderSourceMatchingAsTakerAndMakerWithPriority() { + // Order book looks like: + // | 2.7200 | + // | 2.7100 | + // (os) ########## | 2.6080 | + // limit order ### + (os) ###### | 2.6060 | limit order --> new last price: taker + // | 2.5050 | --> prev. last price + // (os) ## | 2.5040 | + // | 2.4010 | + // | 2.4000 | + + market := s.CreateMarket("ucre", "uusd") + mmAddr := s.FundedAccount(1, enoughCoins) + s.MakeLastPrice(market.Id, mmAddr, utils.ParseDec("2.505")) + + feeCollector := market.MustGetFeeCollectorAddress() + feeAmountBeforeMatching := s.GetAllBalances(feeCollector) + + ordererAddr := s.FundedAccount(2, enoughCoins) + _, order, res := s.PlaceLimitOrder( + market.Id, ordererAddr, true, utils.ParseDec("2.6060"), sdk.NewInt(7_999999), time.Hour) + s.AssertEqual(utils.ParseDec("2.5050"), *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + + s.AssertEqual(sdk.ZeroInt(), res.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("0uusd"), res.Paid) + s.AssertEqual(utils.ParseCoin("0ucre"), res.Received) + + s.NextBlock() + + order, found := s.keeper.GetOrder(s.Ctx, order.Id) + s.Require().True(found) + + ordererAddr2 := s.FundedAccount(3, enoughCoins) + order2 := s.PlaceBatchLimitOrder( + market.Id, ordererAddr2, false, utils.ParseDec("2.6060"), sdk.NewInt(3_000000), time.Hour) + order2, found = s.keeper.GetOrder(s.Ctx, order2.Id) + s.Require().True(found) + + os := types.NewMockOrderSource( + "mockOrderSource", + types.NewMockOrderSourceOrder(false, utils.ParseDec("2.608"), sdk.NewInt(10_000000)), + types.NewMockOrderSourceOrder(false, utils.ParseDec("2.606"), sdk.NewInt(6_000000)), + types.NewMockOrderSourceOrder(false, utils.ParseDec("2.504"), sdk.NewInt(2_000000))) + s.FundAccount(os.Address, enoughCoins) + s.App.ExchangeKeeper = *s.App.ExchangeKeeper.SetOrderSources(os) + s.keeper = s.App.ExchangeKeeper + + osBalanceBeforeMatching := s.GetAllBalances(os.Address) + + s.Ctx = s.Ctx.WithEventManager(sdk.NewEventManager()) + s.Require().NoError(s.keeper.RunBatchMatching(s.Ctx, market)) + + ev := s.getEventOrderFilled(order.Id) + + s.AssertEqual(sdk.NewInt(7_999999), ev.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("20_645998uusd"), ev.Paid) + s.AssertEqual(utils.ParseCoin("7_975999ucre"), ev.Received) + + ev2 := s.getEventOrderFilled(order2.Id) + s.Require().Nil(ev2) + + order, found = s.keeper.GetOrder(s.Ctx, order.Id) + s.Require().False(found) + + order2, found = s.keeper.GetOrder(s.Ctx, order2.Id) + s.Require().True(found) + s.AssertEqual(sdk.NewInt(3_000000), order2.OpenQuantity) + s.AssertEqual(sdk.NewInt(3_000000), order2.RemainingDeposit) + + ev_os := s.getEventOrderSourceOrdersFilled("mockOrderSource") + s.AssertEqual(sdk.NewInt(7_999999), ev_os.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("20_645998uusd"), ev_os.Received) + s.AssertEqual(utils.ParseCoin("7_991000ucre"), ev_os.Paid) + + s.AssertEqual(utils.ParseDec("2.6060"), *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + + feeAmountAfterMatching := s.GetAllBalances(feeCollector) + feeAmount := feeAmountAfterMatching.Sub(feeAmountBeforeMatching) + s.AssertEqual(utils.ParseCoins("15001ucre"), feeAmount) + + osBalanceAfterMatching := s.GetAllBalances(os.Address) + osBalanceDiff, _ := osBalanceAfterMatching.SafeSub(osBalanceBeforeMatching) + expectedOsBalancesDiff := sdk.Coins{ + sdk.Coin{Denom: "ucre", Amount: sdk.NewInt(-7991000)}, + utils.ParseCoin("20_645998uusd")} + s.AssertEqual(expectedOsBalancesDiff, osBalanceDiff) +} + +func (s *KeeperTestSuite) TestOrderSourceMatchingAsTakerAndMakerWithSamePriority() { + // Order book looks like: + // | 2.7200 | + // | 2.7100 | + // (os) ########## | 2.6080 | + // limit order ### + limit order ###### | 2.6060 | limit order --> new last price: taker + // | 2.5050 | --> prev. last price + // (os) ## | 2.5040 | + // | 2.4010 | + // | 2.4000 | + + market := s.CreateMarket("ucre", "uusd") + mmAddr := s.FundedAccount(1, enoughCoins) + s.MakeLastPrice(market.Id, mmAddr, utils.ParseDec("2.505")) + + feeCollector := market.MustGetFeeCollectorAddress() + feeAmountBeforeMatching := s.GetAllBalances(feeCollector) + + ordererAddr := s.FundedAccount(2, enoughCoins) + _, order, res := s.PlaceLimitOrder( + market.Id, ordererAddr, true, utils.ParseDec("2.6060"), sdk.NewInt(7_999999), time.Hour) + s.AssertEqual(utils.ParseDec("2.5050"), *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + + s.AssertEqual(sdk.ZeroInt(), res.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("0uusd"), res.Paid) + s.AssertEqual(utils.ParseCoin("0ucre"), res.Received) + + s.NextBlock() + + order, found := s.keeper.GetOrder(s.Ctx, order.Id) + s.Require().True(found) + + ordererAddr2 := s.FundedAccount(3, enoughCoins) + order2 := s.PlaceBatchLimitOrder( + market.Id, ordererAddr2, false, utils.ParseDec("2.6060"), sdk.NewInt(3_000000), time.Hour) + order2, found = s.keeper.GetOrder(s.Ctx, order2.Id) + s.Require().True(found) + + ordererAddr3 := s.FundedAccount(4, enoughCoins) + order3 := s.PlaceBatchLimitOrder( + market.Id, ordererAddr3, false, utils.ParseDec("2.6060"), sdk.NewInt(6_000000), time.Hour) + order3, found = s.keeper.GetOrder(s.Ctx, order3.Id) + s.Require().True(found) + + os := types.NewMockOrderSource( + "mockOrderSource", + types.NewMockOrderSourceOrder(false, utils.ParseDec("2.608"), sdk.NewInt(10_000000)), + types.NewMockOrderSourceOrder(false, utils.ParseDec("2.504"), sdk.NewInt(2_000000))) + s.FundAccount(os.Address, enoughCoins) + s.App.ExchangeKeeper = *s.App.ExchangeKeeper.SetOrderSources(os) + s.keeper = s.App.ExchangeKeeper + + osBalanceBeforeMatching := s.GetAllBalances(os.Address) + + s.Ctx = s.Ctx.WithEventManager(sdk.NewEventManager()) + s.Require().NoError(s.keeper.RunBatchMatching(s.Ctx, market)) + + ev := s.getEventOrderFilled(order.Id) + + s.AssertEqual(sdk.NewInt(7_999999), ev.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("20_645998uusd"), ev.Paid) + s.AssertEqual(utils.ParseCoin("7_975999ucre"), ev.Received) + + ev2 := s.getEventOrderFilled(order2.Id) + s.AssertEqual(sdk.NewInt(1_999999), ev2.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("5_204179uusd"), ev2.Received) + s.AssertEqual(utils.ParseCoin("1_999999ucre"), ev2.Paid) + + ev3 := s.getEventOrderFilled(order3.Id) + s.AssertEqual(sdk.NewInt(4_000000), ev3.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("10_408364uusd"), ev3.Received) + s.AssertEqual(utils.ParseCoin("4_000000ucre"), ev3.Paid) + + order, found = s.keeper.GetOrder(s.Ctx, order.Id) + s.Require().False(found) + + order2, found = s.keeper.GetOrder(s.Ctx, order2.Id) + s.Require().True(found) + s.AssertEqual(sdk.NewInt(1_000001), order2.OpenQuantity) + s.AssertEqual(sdk.NewInt(1_000001), order2.RemainingDeposit) + + order3, found = s.keeper.GetOrder(s.Ctx, order3.Id) + s.Require().True(found) + s.AssertEqual(sdk.NewInt(2_000000), order3.OpenQuantity) + s.AssertEqual(sdk.NewInt(2_000000), order3.RemainingDeposit) + + ev_os := s.getEventOrderSourceOrdersFilled("mockOrderSource") + s.AssertEqual(sdk.NewInt(2_000000), ev_os.ExecutedQuantity) + s.AssertEqual(utils.ParseCoin("5_010001uusd"), ev_os.Received) + s.AssertEqual(utils.ParseCoin("2_000000ucre"), ev_os.Paid) + + s.AssertEqual(utils.ParseDec("2.6060"), *s.App.ExchangeKeeper.MustGetMarketState(s.Ctx, market.Id).LastPrice) + + feeAmountAfterMatching := s.GetAllBalances(feeCollector) + feeAmount := feeAmountAfterMatching.Sub(feeAmountBeforeMatching) + s.AssertEqual(utils.ParseCoins("24000ucre,23454uusd"), feeAmount) + + osBalanceAfterMatching := s.GetAllBalances(os.Address) + osBalanceDiff, _ := osBalanceAfterMatching.SafeSub(osBalanceBeforeMatching) + expectedOsBalancesDiff := sdk.Coins{ + sdk.Coin{Denom: "ucre", Amount: sdk.NewInt(-2000000)}, + utils.ParseCoin("5_010001uusd")} + s.AssertEqual(expectedOsBalancesDiff, osBalanceDiff) }