Squash merge swap-acceptance branch (#956)
* add failing acceptance test for a user depositing into a pool
* implement GetAccount test helper
* implement swap.MsgDeposit for creating and adding liquidity to a pool
* update aliases, add event types, and fix typo/compiler errors in handler
test
* use only aliases names in handler test (don't use swap types -- ensures
we have run aliasgen), add assertion for even type message
* implement account and module account balance checks in handler test
* fill out handler assertions for testing keeper state and events
* update signed json representation and register swap/MsgDeposit for
proper encoding
* fill out boilerplate to get handler test to compile
* alias gen for pool
* add handling of message type; fill in deposit keeper method for
succesful compile; noop but test assertions now run up to module acc not
nil check
* add module account permissions for swap module -- fixes module account
creation; pass account keeper and supply keeper into swap keeper to
allow the ability to work with user and module accounts
* implement create pool logic for msg deposit; allows creation of a of new
pool, checking params to see if it is allowed. Initi shares are set,
and senders number of shares are stored
* Swap migrations scaffolding (#925)
* swap module scaffolding
* global swap fee
* can't think of a reason for begin blocker; removing for abci.go for now;
* test pair types; refactor pair name logic; simplify pairs validation and
fix stack overflow error
* check comparison
* use test package
* init swap module genesis
* add basic marshall tests
* remove reward apy from pairs
* fix integration helpers
* use max swap fee constant; fix validation of swap fee; add tests to
cover param validation and param set setup
* use noerror over nil
* start genesis tests
* test param set validation mirrors param validation
* add genesis tests
* remove print statement
* add subtests for genesis test cases; add extra querier test for unknown
route; add keeper params testing
* add spec
* update swagger
* find replace hard -> swap in comments
* remove unused method
* rename pairs to allowed pools; pool is more commonly used, and
allowedPool makes it more clear what swap parameter is for. In
addition, we won't conflict with Pool data structure for storing a
created pool in the store.
* remove generated link
* missed spec rename
* validate token order for allowed pools
* fix swagger
* json should be snakecase; change allowedPools to allowed_pools
* add legacy types
* add swap genesis to v0_15 migration
* add legacy types
* add swap genesis to v0_15 migration
* migration revisions
Co-authored-by: Nick DeLuca <nickdeluca08@gmail.com>
* keeper todos
* update keeper tests
* type todos
* update types tests
* tx deposit cli cmd
* tx deposit rest
* Swap module simulation scaffolding (#924)
* sims scaffolding
* add noop operation
* genesis revisions
* add param changes
* mvoe persistance methods to main keeper file, consolidate tests
* make helper methods private. they are tested via deposit method, and
unit testing them would make test suite brittle and refactoring
difficult
* use more clear coin variables
* code 1 is reserved, use code 2 and sequence all errors
* remove todo
* Implement deadline for swap module module message. This is implemented in
handler with a interface to easily apply to it to all messages, and
separate msg validation concerns from the keeper
* move allowed pools to params -- let pool and pool_test focus on pool domain logic, not
parameter & governance concerns
* update alias
* add unitless implementatin of constant product liquidity pool to
isolate and enapsulate liquidity logic. Swap methods interfaces are
added, but implementation not yet added
* nits and todos
* add ErrInvalidPool
* add tests for edge cases around pool depletion; add explicit panic for
edge case that results in a pool reserve being zero; handle pool
reinitialization if it is empty
* touch up comments and flush out the rest of assertions
* add data structures for keeper state storage separate from pool domain
objects, and improve structure for easier querying
* rename pool name to pool key for events
* add support for a denominated pool that uses sdk.Coins and sdk.Coin
arguments, keeping tracking of the units in the base pool. This gives
nice separation between pool logic, and coin/denom logic
* refactor keeper to use new records for storage, and implement pool
deposit using the denominated pool
* address previous PR comment - reminder for migration if changing
account permissions
* msg deposit should validate that denoms are not equal
* add godoc comments
* golint and some poolName -> poolID cleanup
* implement adding liquidity to an existing pool
* hardcode pools in sims
* touch up comment
* withdraw keeper logic
* withdraw type updates
* add withdraw msg tx handler
* initial withdraw test
* fix panic
* use new denominated pool with existing shares
* fix: check args on deposit cmd
* add slippage limit check for depositing to an existing pool
* send coins just before event emission
* check liquidity returned is greater than zero for both coins; ensure
returned number of shares are greater than zero
* add deadline to msgwithdraw
* register msgwithdraw
* scaffold msgwithdraw types test
* register the correct msg
* modify swap functions to also return the amount paid for the pool swap
fee. This will be used to calculate slippage and for event tracking
* add slippage types
* add expected withdrawal coins
* calculate slippage against expected coins
* update withdraw keeper tests
* spelling, improve comments on add liquidity math
* typo
* typo
* grammer
* typo / grammer
* remove pool_id from withdraw msg
* add slippage to tx cmd
* TestWithdraw_Partial
* nit
* add withdraw no pool, no deposit record tests
* drop event check on partial withdraw test
* fix broken link
* fix broken link
* resolve merge conflicts
* ensure swap fee can not be equal to 1; add full implementation of swap
pool methods; these implementation ensure that the pool invariant is
always greater or equal to the previous invariant
* refactor duplicated code into private swap methods
* add runtime assertion to always ensure invariant is greater or equal
to the previous invariant sub fee on swaps
* improve comments for base pool swap functions
* add swap exact input and output methods to denominated pool that wrap
the base pool interface for swapping
* comment touch ups
* more comment touchups
* fix msg deposit struct tag (#943)
* use better name for swap calculation private methods
* nits: golint
* fix misspelling in method name
* Add HARD token governance committee for Hard module (#941)
* add hard gov token committee
* revisions: update migration
* revisions: update test/data file
* initial revisions
* add TokenCommittee JSONMarshal test
* fix SetPermissions method
* remove BaseCommittee Type field
* add incentive params to allowed params
* Add SWP token governance committee for Swap module (#946)
* add swp token commitee to migration
* update test, add gen export utility method
* final revisions: add TODO
* remove slippage from withdraw to use min values for coins; add
additional validation test cases
* update alias for swap module
* add withdraw tests to handler for increased coverage; note: first pass,
improvements still yet to be made here
* refact withdraw keeper to use min amounts; panic for cases that do not
happen in normal situations
* lint fixes
* use total shares to track if pool should be deleted; add more in depth
withdraw comment
* add exact args for withdraw cmd
* extract record update methods
* update depositor share record if it exists -- do not overwrite an
existing record; ensures no loss of shares if the same address deposits
more than once
* Swap queries: deposit, pool, pools (#949)
* query deposits types
* implement deposit querier keeper methods
* query deposits CLI
* query deposits REST
* query types for pool/pools
* pool/pools querier keeper methods
* pool/pools CLI
* pool/pools REST
* basic pool/pools query tests
* basic deposit querier test
* iterate share records via owner bytes
* nit: add example for querying deposits by owner only
Co-authored-by: karzak <kjydavis3@gmail.com>
* feat: add REST tx handler for swap LP withdrawals
Co-authored-by: Nick DeLuca <nickdeluca08@gmail.com>
Co-authored-by: Denali Marsh <denali@kava.io>
Co-authored-by: denalimarsh <denalimarsh@gmail.com>
Co-authored-by: karzak <kjydavis3@gmail.com>
2021-07-13 11:38:15 +00:00
|
|
|
package simulation
|
|
|
|
|
|
2022-01-08 00:39:27 +00:00
|
|
|
// import (
|
|
|
|
|
// "errors"
|
|
|
|
|
// "fmt"
|
|
|
|
|
// "math/big"
|
|
|
|
|
// "math/rand"
|
|
|
|
|
// "time"
|
|
|
|
|
|
|
|
|
|
// "github.com/cosmos/cosmos-sdk/baseapp"
|
|
|
|
|
// "github.com/cosmos/cosmos-sdk/codec"
|
|
|
|
|
// "github.com/cosmos/cosmos-sdk/simapp/helpers"
|
|
|
|
|
// sdk "github.com/cosmos/cosmos-sdk/types"
|
|
|
|
|
// authexported "github.com/cosmos/cosmos-sdk/x/auth/exported"
|
|
|
|
|
// "github.com/cosmos/cosmos-sdk/x/simulation"
|
|
|
|
|
|
|
|
|
|
// appparams "github.com/kava-labs/kava/app/params"
|
|
|
|
|
// "github.com/kava-labs/kava/x/swap/keeper"
|
|
|
|
|
// "github.com/kava-labs/kava/x/swap/types"
|
|
|
|
|
// )
|
|
|
|
|
|
|
|
|
|
// var (
|
|
|
|
|
// //nolint
|
|
|
|
|
// noOpMsg = simulation.NoOpMsg(types.ModuleName)
|
|
|
|
|
// errorNotEnoughCoins = errors.New("account doesn't have enough coins")
|
|
|
|
|
// )
|
|
|
|
|
|
|
|
|
|
// // Simulation operation weights constants
|
|
|
|
|
// const (
|
|
|
|
|
// OpWeightMsgDeposit = "op_weight_msg_deposit"
|
|
|
|
|
// OpWeightMsgWithdraw = "op_weight_msg_withdraw"
|
|
|
|
|
// OpWeightMsgSwapExactForTokens = "op_weight_msg_swap_exact_for_tokens"
|
|
|
|
|
// OpWeightMsgSwapForExactTokens = "op_weight_msg_swap_for_exact_tokens"
|
|
|
|
|
// )
|
|
|
|
|
|
|
|
|
|
// // WeightedOperations returns all the operations from the module with their respective weights
|
|
|
|
|
// func WeightedOperations(
|
|
|
|
|
// appParams simulation.AppParams, cdc *codec.Codec, ak types.AccountKeeper, k keeper.Keeper,
|
|
|
|
|
// ) simulation.WeightedOperations {
|
|
|
|
|
// var weightMsgDeposit int
|
|
|
|
|
// var weightMsgWithdraw int
|
|
|
|
|
// var weightMsgSwapExactForTokens int
|
|
|
|
|
// var weightMsgSwapForExactTokens int
|
|
|
|
|
|
|
|
|
|
// appParams.GetOrGenerate(cdc, OpWeightMsgDeposit, &weightMsgDeposit, nil,
|
|
|
|
|
// func(_ *rand.Rand) {
|
|
|
|
|
// weightMsgDeposit = appparams.DefaultWeightMsgDeposit
|
|
|
|
|
// },
|
|
|
|
|
// )
|
|
|
|
|
|
|
|
|
|
// appParams.GetOrGenerate(cdc, OpWeightMsgWithdraw, &weightMsgWithdraw, nil,
|
|
|
|
|
// func(_ *rand.Rand) {
|
|
|
|
|
// weightMsgWithdraw = appparams.DefaultWeightMsgWithdraw
|
|
|
|
|
// },
|
|
|
|
|
// )
|
|
|
|
|
|
|
|
|
|
// appParams.GetOrGenerate(cdc, OpWeightMsgSwapExactForTokens, &weightMsgSwapExactForTokens, nil,
|
|
|
|
|
// func(_ *rand.Rand) {
|
|
|
|
|
// weightMsgSwapExactForTokens = appparams.DefaultWeightMsgSwapExactForTokens
|
|
|
|
|
// },
|
|
|
|
|
// )
|
|
|
|
|
|
|
|
|
|
// appParams.GetOrGenerate(cdc, OpWeightMsgSwapForExactTokens, &weightMsgSwapForExactTokens, nil,
|
|
|
|
|
// func(_ *rand.Rand) {
|
|
|
|
|
// weightMsgSwapForExactTokens = appparams.DefaultWeightMsgSwapForExactTokens
|
|
|
|
|
// },
|
|
|
|
|
// )
|
|
|
|
|
|
|
|
|
|
// return simulation.WeightedOperations{
|
|
|
|
|
// simulation.NewWeightedOperation(
|
|
|
|
|
// weightMsgDeposit,
|
|
|
|
|
// SimulateMsgDeposit(ak, k),
|
|
|
|
|
// ),
|
|
|
|
|
// simulation.NewWeightedOperation(
|
|
|
|
|
// weightMsgWithdraw,
|
|
|
|
|
// SimulateMsgWithdraw(ak, k),
|
|
|
|
|
// ),
|
|
|
|
|
// simulation.NewWeightedOperation(
|
|
|
|
|
// weightMsgSwapExactForTokens,
|
|
|
|
|
// SimulateMsgSwapExactForTokens(ak, k),
|
|
|
|
|
// ),
|
|
|
|
|
// simulation.NewWeightedOperation(
|
|
|
|
|
// weightMsgSwapForExactTokens,
|
|
|
|
|
// SimulateMsgSwapForExactTokens(ak, k),
|
|
|
|
|
// ),
|
|
|
|
|
// }
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // SimulateMsgDeposit generates a MsgDeposit
|
|
|
|
|
// func SimulateMsgDeposit(ak types.AccountKeeper, k keeper.Keeper) simulation.Operation {
|
|
|
|
|
// return func(
|
|
|
|
|
// r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, chainID string,
|
|
|
|
|
// ) (simulation.OperationMsg, []simulation.FutureOperation, error) {
|
|
|
|
|
// // Get possible pools and shuffle so that deposits are evenly distributed across pools
|
|
|
|
|
// params := k.GetParams(ctx)
|
|
|
|
|
// allowedPools := params.AllowedPools
|
|
|
|
|
// r.Shuffle(len(allowedPools), func(i, j int) {
|
|
|
|
|
// allowedPools[i], allowedPools[j] = allowedPools[j], allowedPools[i]
|
|
|
|
|
// })
|
|
|
|
|
|
|
|
|
|
// // Find an account-pool pair that is likely to result in a successful deposit
|
|
|
|
|
// blockTime := ctx.BlockHeader().Time
|
|
|
|
|
// depositor, allowedPool, found := findValidAccountAllowedPoolPair(accs, allowedPools, func(acc simulation.Account, pool types.AllowedPool) bool {
|
|
|
|
|
// account := ak.GetAccount(ctx, acc.Address)
|
|
|
|
|
|
|
|
|
|
// err := validateDepositor(ctx, k, pool, account, blockTime)
|
|
|
|
|
// if err == errorNotEnoughCoins {
|
|
|
|
|
// return false // keep searching
|
|
|
|
|
// } else if err != nil {
|
|
|
|
|
// panic(err) // raise errors
|
|
|
|
|
// }
|
|
|
|
|
// return true // found valid pair
|
|
|
|
|
// })
|
|
|
|
|
// if !found {
|
|
|
|
|
// return simulation.NewOperationMsgBasic(types.ModuleName, "no-operation (no valid allowed pool and depositor)", "", false, nil), nil, nil
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // Get random slippage amount between 1-99%
|
2023-04-05 23:21:59 +00:00
|
|
|
// slippageRaw, err := RandIntInclusive(r, sdk.OneInt(), sdkmath.NewInt(99))
|
2022-01-08 00:39:27 +00:00
|
|
|
// if err != nil {
|
|
|
|
|
// panic(err)
|
|
|
|
|
// }
|
|
|
|
|
// slippage := slippageRaw.ToDec().Quo(sdk.NewDec(100))
|
|
|
|
|
|
|
|
|
|
// // Generate random deadline
|
|
|
|
|
// deadline := genRandDeadline(r, blockTime)
|
|
|
|
|
|
|
|
|
|
// depositorAcc := ak.GetAccount(ctx, depositor.Address)
|
|
|
|
|
// depositorCoins := depositorAcc.SpendableCoins(blockTime)
|
|
|
|
|
|
|
|
|
|
// // Construct initial msg (without coin amounts)
|
|
|
|
|
// msg := types.NewMsgDeposit(depositorAcc.GetAddress(), sdk.Coin{}, sdk.Coin{}, slippage, deadline)
|
|
|
|
|
|
|
|
|
|
// // Populate msg with randomized token amounts
|
|
|
|
|
// pool, found := k.GetPool(ctx, allowedPool.Name())
|
|
|
|
|
// if !found { // Pool doesn't exist: first deposit
|
|
|
|
|
// depositTokenA := randCoinFromCoins(r, depositorCoins, allowedPool.TokenA)
|
|
|
|
|
// msg.TokenA = depositTokenA
|
|
|
|
|
|
|
|
|
|
// depositTokenB := randCoinFromCoins(r, depositorCoins, allowedPool.TokenB)
|
|
|
|
|
// msg.TokenB = depositTokenB
|
|
|
|
|
// } else { // Pool exists: successive deposit
|
|
|
|
|
// var denomX string // Denom X is the token denom in the pool with the larger amount
|
|
|
|
|
// var denomY string // Denom Y is the token denom in the pool with the larger amount
|
|
|
|
|
// if pool.ReservesA.Amount.GTE(pool.ReservesB.Amount) {
|
|
|
|
|
// denomX = pool.ReservesA.Denom
|
|
|
|
|
// denomY = pool.ReservesB.Denom
|
|
|
|
|
// } else {
|
|
|
|
|
// denomX = pool.ReservesB.Denom
|
|
|
|
|
// denomY = pool.ReservesA.Denom
|
|
|
|
|
// }
|
|
|
|
|
// depositTokenY := randCoinFromCoins(r, depositorCoins, denomY)
|
|
|
|
|
// msg.TokenA = depositTokenY
|
|
|
|
|
|
|
|
|
|
// // Calculate the pool's slippage ratio and use it to build other coin
|
|
|
|
|
// ratio := pool.Reserves().AmountOf(denomX).ToDec().Quo(pool.Reserves().AmountOf(denomY).ToDec())
|
|
|
|
|
// amtTokenX := depositTokenY.Amount.ToDec().Mul(ratio).RoundInt()
|
|
|
|
|
// depositTokenX := sdk.NewCoin(denomX, amtTokenX)
|
|
|
|
|
// if depositorCoins.AmountOf(denomX).LT(amtTokenX) {
|
|
|
|
|
// return simulation.NewOperationMsgBasic(types.ModuleName, "no-operation (depositor has insufficient coins)", "", false, nil), nil, nil
|
|
|
|
|
// }
|
|
|
|
|
// msg.TokenB = depositTokenX
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// err = msg.ValidateBasic()
|
|
|
|
|
// if err != nil {
|
|
|
|
|
// return noOpMsg, nil, nil
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// tx := helpers.GenTx(
|
|
|
|
|
// []sdk.Msg{msg},
|
|
|
|
|
// sdk.NewCoins(),
|
|
|
|
|
// helpers.DefaultGenTxGas,
|
|
|
|
|
// chainID,
|
|
|
|
|
// []uint64{depositorAcc.GetAccountNumber()},
|
|
|
|
|
// []uint64{depositorAcc.GetSequence()},
|
|
|
|
|
// depositor.PrivKey,
|
|
|
|
|
// )
|
|
|
|
|
|
|
|
|
|
// _, result, err := app.Deliver(tx)
|
|
|
|
|
// if err != nil {
|
|
|
|
|
// // to aid debugging, add the stack trace to the comment field of the returned opMsg
|
|
|
|
|
// return simulation.NewOperationMsg(msg, false, fmt.Sprintf("%+v", err)), nil, err
|
|
|
|
|
// }
|
|
|
|
|
// return simulation.NewOperationMsg(msg, true, result.Log), nil, nil
|
|
|
|
|
// }
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // SimulateMsgWithdraw generates a MsgWithdraw
|
|
|
|
|
// func SimulateMsgWithdraw(ak types.AccountKeeper, k keeper.Keeper) simulation.Operation {
|
|
|
|
|
// return func(
|
|
|
|
|
// r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, chainID string,
|
|
|
|
|
// ) (simulation.OperationMsg, []simulation.FutureOperation, error) {
|
|
|
|
|
|
|
|
|
|
// poolRecords := k.GetAllPools(ctx)
|
|
|
|
|
// r.Shuffle(len(poolRecords), func(i, j int) {
|
|
|
|
|
// poolRecords[i], poolRecords[j] = poolRecords[j], poolRecords[i]
|
|
|
|
|
// })
|
|
|
|
|
|
|
|
|
|
// // Find an account-pool pair for which withdraw is possible
|
|
|
|
|
// withdrawer, poolRecord, found := findValidAccountPoolRecordPair(accs, poolRecords, func(acc simulation.Account, poolRecord types.PoolRecord) bool {
|
|
|
|
|
// _, found := k.GetDepositorShares(ctx, acc.Address, poolRecord.PoolID)
|
|
|
|
|
// return found
|
|
|
|
|
// })
|
|
|
|
|
// if !found {
|
|
|
|
|
// return simulation.NewOperationMsgBasic(types.ModuleName, "no-operation (no valid pool record and withdrawer)", "", false, nil), nil, nil
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// withdrawerAcc := ak.GetAccount(ctx, withdrawer.Address)
|
|
|
|
|
// shareRecord, _ := k.GetDepositorShares(ctx, withdrawerAcc.GetAddress(), poolRecord.PoolID)
|
|
|
|
|
// denominatedPool, err := types.NewDenominatedPoolWithExistingShares(poolRecord.Reserves(), poolRecord.TotalShares)
|
|
|
|
|
// if err != nil {
|
|
|
|
|
// return noOpMsg, nil, nil
|
|
|
|
|
// }
|
|
|
|
|
// coinsOwned := denominatedPool.ShareValue(shareRecord.SharesOwned)
|
|
|
|
|
|
|
|
|
|
// // Get random amount of shares between 2-10% of the total
|
2023-04-05 23:21:59 +00:00
|
|
|
// sharePercentage, err := RandIntInclusive(r, sdkmath.NewInt(2), sdkmath.NewInt(10))
|
2022-01-08 00:39:27 +00:00
|
|
|
// if err != nil {
|
|
|
|
|
// panic(err)
|
|
|
|
|
// }
|
2023-04-05 23:21:59 +00:00
|
|
|
// shares := shareRecord.SharesOwned.Mul(sharePercentage).Quo(sdkmath.NewInt(100))
|
2022-01-08 00:39:27 +00:00
|
|
|
|
|
|
|
|
// // Expect minimum token amounts relative to the % of shares owned and withdrawn
|
|
|
|
|
// oneLessThanSharePercentage := sharePercentage.Sub(sdk.OneInt())
|
|
|
|
|
|
|
|
|
|
// amtTokenAOwned := coinsOwned.AmountOf(poolRecord.ReservesA.Denom)
|
2023-04-05 23:21:59 +00:00
|
|
|
// minAmtTokenA := amtTokenAOwned.Mul(oneLessThanSharePercentage).Quo(sdkmath.NewInt(100))
|
2022-01-08 00:39:27 +00:00
|
|
|
// minTokenA := sdk.NewCoin(poolRecord.ReservesA.Denom, minAmtTokenA)
|
|
|
|
|
|
|
|
|
|
// amtTokenBOwned := coinsOwned.AmountOf(poolRecord.ReservesB.Denom)
|
2023-04-05 23:21:59 +00:00
|
|
|
// minTokenAmtB := amtTokenBOwned.Mul(oneLessThanSharePercentage).Quo(sdkmath.NewInt(100))
|
2022-01-08 00:39:27 +00:00
|
|
|
// minTokenB := sdk.NewCoin(poolRecord.ReservesB.Denom, minTokenAmtB)
|
|
|
|
|
|
|
|
|
|
// // Generate random deadline
|
|
|
|
|
// blockTime := ctx.BlockHeader().Time
|
|
|
|
|
// deadline := genRandDeadline(r, blockTime)
|
|
|
|
|
|
|
|
|
|
// // Construct MsgWithdraw
|
|
|
|
|
// msg := types.NewMsgWithdraw(withdrawerAcc.GetAddress(), shares, minTokenA, minTokenB, deadline)
|
|
|
|
|
// err = msg.ValidateBasic()
|
|
|
|
|
// if err != nil {
|
|
|
|
|
// return noOpMsg, nil, nil
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// tx := helpers.GenTx(
|
|
|
|
|
// []sdk.Msg{msg},
|
|
|
|
|
// sdk.NewCoins(),
|
|
|
|
|
// helpers.DefaultGenTxGas,
|
|
|
|
|
// chainID,
|
|
|
|
|
// []uint64{withdrawerAcc.GetAccountNumber()},
|
|
|
|
|
// []uint64{withdrawerAcc.GetSequence()},
|
|
|
|
|
// withdrawer.PrivKey,
|
|
|
|
|
// )
|
|
|
|
|
|
|
|
|
|
// _, result, err := app.Deliver(tx)
|
|
|
|
|
// if err != nil {
|
|
|
|
|
// // to aid debugging, add the stack trace to the comment field of the returned opMsg
|
|
|
|
|
// return simulation.NewOperationMsg(msg, false, fmt.Sprintf("%+v", err)), nil, err
|
|
|
|
|
// }
|
|
|
|
|
// return simulation.NewOperationMsg(msg, true, result.Log), nil, nil
|
|
|
|
|
|
|
|
|
|
// }
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // SimulateMsgSwapExactForTokens generates a MsgSwapExactForTokens
|
|
|
|
|
// func SimulateMsgSwapExactForTokens(ak types.AccountKeeper, k keeper.Keeper) simulation.Operation {
|
|
|
|
|
// return func(
|
|
|
|
|
// r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, chainID string,
|
|
|
|
|
// ) (simulation.OperationMsg, []simulation.FutureOperation, error) {
|
|
|
|
|
|
|
|
|
|
// poolRecords := k.GetAllPools(ctx)
|
|
|
|
|
// r.Shuffle(len(poolRecords), func(i, j int) {
|
|
|
|
|
// poolRecords[i], poolRecords[j] = poolRecords[j], poolRecords[i]
|
|
|
|
|
// })
|
|
|
|
|
|
|
|
|
|
// // Find an account-pool pair for which trade is possible
|
|
|
|
|
// trader, poolRecord, found := findValidAccountPoolRecordPair(accs, poolRecords, func(acc simulation.Account, poolRecord types.PoolRecord) bool {
|
|
|
|
|
// traderAcc := ak.GetAccount(ctx, acc.Address)
|
|
|
|
|
// balanceTokenA := traderAcc.GetCoins().AmountOf(poolRecord.ReservesA.Denom)
|
|
|
|
|
// balanceTokenB := traderAcc.GetCoins().AmountOf(poolRecord.ReservesB.Denom)
|
|
|
|
|
// if !balanceTokenA.IsPositive() || !balanceTokenB.IsPositive() {
|
|
|
|
|
// return false
|
|
|
|
|
// }
|
|
|
|
|
// return true
|
|
|
|
|
// })
|
|
|
|
|
// if !found {
|
|
|
|
|
// return simulation.NewOperationMsgBasic(types.ModuleName, "no-operation (no valid pool record and trader)", "", false, nil), nil, nil
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // Select input token
|
2023-04-05 23:21:59 +00:00
|
|
|
// randInt, err := RandInt(r, sdk.OneInt(), sdkmath.NewInt(9))
|
2022-01-08 00:39:27 +00:00
|
|
|
// if err != nil {
|
|
|
|
|
// panic(err)
|
|
|
|
|
// }
|
|
|
|
|
// inputToken := poolRecord.ReservesA
|
|
|
|
|
// outputToken := poolRecord.ReservesB
|
|
|
|
|
// if randInt.Int64()%2 == 0 {
|
|
|
|
|
// inputToken = poolRecord.ReservesB
|
|
|
|
|
// outputToken = poolRecord.ReservesA
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // Select entity (trader account or pool) with smaller token amount
|
|
|
|
|
// traderAcc := ak.GetAccount(ctx, trader.Address)
|
|
|
|
|
// maxTradeAmount := inputToken.Amount
|
|
|
|
|
// if traderAcc.GetCoins().AmountOf(inputToken.Denom).LT(inputToken.Amount) {
|
|
|
|
|
// maxTradeAmount = traderAcc.GetCoins().AmountOf(inputToken.Denom)
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // Exact input token is between 2-10% of the max trade amount
|
2023-04-05 23:21:59 +00:00
|
|
|
// percentage, err := RandIntInclusive(r, sdkmath.NewInt(2), sdkmath.NewInt(10))
|
2022-01-08 00:39:27 +00:00
|
|
|
// if err != nil {
|
|
|
|
|
// panic(err)
|
|
|
|
|
// }
|
2023-04-05 23:21:59 +00:00
|
|
|
// tradeAmount := maxTradeAmount.Mul(percentage).Quo(sdkmath.NewInt(100))
|
2022-01-08 00:39:27 +00:00
|
|
|
// exactInputToken := sdk.NewCoin(inputToken.Denom, tradeAmount)
|
|
|
|
|
|
|
|
|
|
// // Calculate expected output coin
|
|
|
|
|
// globalSwapFee := k.GetSwapFee(ctx)
|
|
|
|
|
// tradeAmountAfterFee := exactInputToken.Amount.ToDec().Mul(sdk.OneDec().Sub(globalSwapFee)).TruncateInt()
|
|
|
|
|
|
|
|
|
|
// var outputAmt big.Int
|
|
|
|
|
// outputAmt.Mul(outputToken.Amount.BigInt(), tradeAmountAfterFee.BigInt())
|
|
|
|
|
// outputAmt.Quo(&outputAmt, inputToken.Amount.Add(tradeAmountAfterFee).BigInt())
|
2023-04-05 23:21:59 +00:00
|
|
|
// expectedOutTokenAmount := sdkmath.NewIntFromBigInt(&outputAmt)
|
2022-01-08 00:39:27 +00:00
|
|
|
// expectedOutputToken := sdk.NewCoin(outputToken.Denom, expectedOutTokenAmount)
|
|
|
|
|
|
|
|
|
|
// // Get random slippage amount between 50-100%
|
2023-04-05 23:21:59 +00:00
|
|
|
// slippageRaw, err := RandIntInclusive(r, sdkmath.NewInt(50), sdkmath.NewInt(99))
|
2022-01-08 00:39:27 +00:00
|
|
|
// if err != nil {
|
|
|
|
|
// panic(err)
|
|
|
|
|
// }
|
|
|
|
|
// slippage := slippageRaw.ToDec().Quo(sdk.NewDec(100))
|
|
|
|
|
|
|
|
|
|
// // Generate random deadline
|
|
|
|
|
// blockTime := ctx.BlockHeader().Time
|
|
|
|
|
// deadline := genRandDeadline(r, blockTime)
|
|
|
|
|
|
|
|
|
|
// // Construct MsgSwapExactForTokens
|
|
|
|
|
// msg := types.NewMsgSwapExactForTokens(traderAcc.GetAddress(), exactInputToken, expectedOutputToken, slippage, deadline)
|
|
|
|
|
// err = msg.ValidateBasic()
|
|
|
|
|
// if err != nil {
|
|
|
|
|
// return noOpMsg, nil, nil
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// tx := helpers.GenTx(
|
|
|
|
|
// []sdk.Msg{msg},
|
|
|
|
|
// sdk.NewCoins(),
|
|
|
|
|
// helpers.DefaultGenTxGas,
|
|
|
|
|
// chainID,
|
|
|
|
|
// []uint64{traderAcc.GetAccountNumber()},
|
|
|
|
|
// []uint64{traderAcc.GetSequence()},
|
|
|
|
|
// trader.PrivKey,
|
|
|
|
|
// )
|
|
|
|
|
|
|
|
|
|
// _, result, err := app.Deliver(tx)
|
|
|
|
|
// if err != nil {
|
|
|
|
|
// // to aid debugging, add the stack trace to the comment field of the returned opMsg
|
|
|
|
|
// return simulation.NewOperationMsg(msg, false, fmt.Sprintf("%+v", err)), nil, err
|
|
|
|
|
// }
|
|
|
|
|
// return simulation.NewOperationMsg(msg, true, result.Log), nil, nil
|
|
|
|
|
// }
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // SimulateMsgSwapForExactTokens generates a MsgSwapForExactTokens
|
|
|
|
|
// func SimulateMsgSwapForExactTokens(ak types.AccountKeeper, k keeper.Keeper) simulation.Operation {
|
|
|
|
|
// return func(
|
|
|
|
|
// r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, chainID string,
|
|
|
|
|
// ) (simulation.OperationMsg, []simulation.FutureOperation, error) {
|
|
|
|
|
|
|
|
|
|
// poolRecords := k.GetAllPools(ctx)
|
|
|
|
|
// r.Shuffle(len(poolRecords), func(i, j int) {
|
|
|
|
|
// poolRecords[i], poolRecords[j] = poolRecords[j], poolRecords[i]
|
|
|
|
|
// })
|
|
|
|
|
|
|
|
|
|
// // Find an account-pool pair for which trade is possible
|
|
|
|
|
// trader, poolRecord, found := findValidAccountPoolRecordPair(accs, poolRecords, func(acc simulation.Account, poolRecord types.PoolRecord) bool {
|
|
|
|
|
// traderAcc := ak.GetAccount(ctx, acc.Address)
|
|
|
|
|
// balanceTokenA := traderAcc.GetCoins().AmountOf(poolRecord.ReservesA.Denom)
|
|
|
|
|
// balanceTokenB := traderAcc.GetCoins().AmountOf(poolRecord.ReservesB.Denom)
|
|
|
|
|
// if !balanceTokenA.IsPositive() || !balanceTokenB.IsPositive() {
|
|
|
|
|
// return false
|
|
|
|
|
// }
|
|
|
|
|
// return true
|
|
|
|
|
// })
|
|
|
|
|
// if !found {
|
|
|
|
|
// return simulation.NewOperationMsgBasic(types.ModuleName, "no-operation (no valid pool record and trader)", "", false, nil), nil, nil
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // Select input token
|
2023-04-05 23:21:59 +00:00
|
|
|
// randInt, err := RandInt(r, sdk.OneInt(), sdkmath.NewInt(9))
|
2022-01-08 00:39:27 +00:00
|
|
|
// if err != nil {
|
|
|
|
|
// panic(err)
|
|
|
|
|
// }
|
|
|
|
|
// inputToken := poolRecord.ReservesA
|
|
|
|
|
// outputToken := poolRecord.ReservesB
|
|
|
|
|
// if randInt.Int64()%2 == 0 {
|
|
|
|
|
// inputToken = poolRecord.ReservesB
|
|
|
|
|
// outputToken = poolRecord.ReservesA
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // Select entity (trader account or pool) with smaller token amount
|
|
|
|
|
// traderAcc := ak.GetAccount(ctx, trader.Address)
|
|
|
|
|
// maxTradeAmount := inputToken.Amount
|
|
|
|
|
// if traderAcc.GetCoins().AmountOf(inputToken.Denom).LT(inputToken.Amount) {
|
|
|
|
|
// maxTradeAmount = traderAcc.GetCoins().AmountOf(inputToken.Denom)
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // Expected input token is between 2-10% of the max trade amount
|
2023-04-05 23:21:59 +00:00
|
|
|
// percentage, err := RandIntInclusive(r, sdkmath.NewInt(2), sdkmath.NewInt(10))
|
2022-01-08 00:39:27 +00:00
|
|
|
// if err != nil {
|
|
|
|
|
// panic(err)
|
|
|
|
|
// }
|
2023-04-05 23:21:59 +00:00
|
|
|
// tradeAmount := maxTradeAmount.Mul(percentage).Quo(sdkmath.NewInt(100))
|
2022-01-08 00:39:27 +00:00
|
|
|
// expectedInputToken := sdk.NewCoin(inputToken.Denom, tradeAmount)
|
|
|
|
|
|
|
|
|
|
// // Calculate exact output coin
|
|
|
|
|
// globalSwapFee := k.GetSwapFee(ctx)
|
|
|
|
|
// tradeAmountAfterFee := expectedInputToken.Amount.ToDec().Mul(sdk.OneDec().Sub(globalSwapFee)).TruncateInt()
|
|
|
|
|
|
|
|
|
|
// var outputAmt big.Int
|
|
|
|
|
// outputAmt.Mul(outputToken.Amount.BigInt(), tradeAmountAfterFee.BigInt())
|
|
|
|
|
// outputAmt.Quo(&outputAmt, inputToken.Amount.Add(tradeAmountAfterFee).BigInt())
|
2023-04-05 23:21:59 +00:00
|
|
|
// outputTokenAmount := sdkmath.NewIntFromBigInt(&outputAmt)
|
2022-01-08 00:39:27 +00:00
|
|
|
// exactOutputToken := sdk.NewCoin(outputToken.Denom, outputTokenAmount)
|
|
|
|
|
|
|
|
|
|
// // Get random slippage amount between 50-100%
|
2023-04-05 23:21:59 +00:00
|
|
|
// slippageRaw, err := RandIntInclusive(r, sdkmath.NewInt(50), sdkmath.NewInt(99))
|
2022-01-08 00:39:27 +00:00
|
|
|
// if err != nil {
|
|
|
|
|
// panic(err)
|
|
|
|
|
// }
|
|
|
|
|
// slippage := slippageRaw.ToDec().Quo(sdk.NewDec(100))
|
|
|
|
|
|
|
|
|
|
// // Generate random deadline
|
|
|
|
|
// blockTime := ctx.BlockHeader().Time
|
|
|
|
|
// deadline := genRandDeadline(r, blockTime)
|
|
|
|
|
|
|
|
|
|
// // Construct MsgSwapForExactTokens
|
|
|
|
|
// msg := types.NewMsgSwapForExactTokens(traderAcc.GetAddress(), expectedInputToken, exactOutputToken, slippage, deadline)
|
|
|
|
|
// err = msg.ValidateBasic()
|
|
|
|
|
// if err != nil {
|
|
|
|
|
// return noOpMsg, nil, nil
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// tx := helpers.GenTx(
|
|
|
|
|
// []sdk.Msg{msg},
|
|
|
|
|
// sdk.NewCoins(),
|
|
|
|
|
// helpers.DefaultGenTxGas,
|
|
|
|
|
// chainID,
|
|
|
|
|
// []uint64{traderAcc.GetAccountNumber()},
|
|
|
|
|
// []uint64{traderAcc.GetSequence()},
|
|
|
|
|
// trader.PrivKey,
|
|
|
|
|
// )
|
|
|
|
|
|
|
|
|
|
// _, result, err := app.Deliver(tx)
|
|
|
|
|
// if err != nil {
|
|
|
|
|
// // to aid debugging, add the stack trace to the comment field of the returned opMsg
|
|
|
|
|
// return simulation.NewOperationMsg(msg, false, fmt.Sprintf("%+v", err)), nil, err
|
|
|
|
|
// }
|
|
|
|
|
// return simulation.NewOperationMsg(msg, true, result.Log), nil, nil
|
|
|
|
|
// }
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // From a set of coins return a coin of the specified denom with 1-10% of the total amount
|
|
|
|
|
// func randCoinFromCoins(r *rand.Rand, coins sdk.Coins, denom string) sdk.Coin {
|
2023-04-05 23:21:59 +00:00
|
|
|
// percentOfBalance, err := RandIntInclusive(r, sdk.OneInt(), sdkmath.NewInt(10))
|
2022-01-08 00:39:27 +00:00
|
|
|
// if err != nil {
|
|
|
|
|
// panic(err)
|
|
|
|
|
// }
|
|
|
|
|
// balance := coins.AmountOf(denom)
|
2023-04-05 23:21:59 +00:00
|
|
|
// amtToken := balance.Mul(percentOfBalance).Quo(sdkmath.NewInt(100))
|
2022-01-08 00:39:27 +00:00
|
|
|
// return sdk.NewCoin(denom, amtToken)
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// func validateDepositor(ctx sdk.Context, k keeper.Keeper, allowedPool types.AllowedPool,
|
|
|
|
|
// depositor authexported.Account, blockTime time.Time) error {
|
|
|
|
|
// depositorCoins := depositor.SpendableCoins(blockTime)
|
|
|
|
|
// tokenABalance := depositorCoins.AmountOf(allowedPool.TokenA)
|
|
|
|
|
// tokenBBalance := depositorCoins.AmountOf(allowedPool.TokenB)
|
|
|
|
|
|
2023-04-05 23:21:59 +00:00
|
|
|
// oneThousand := sdkmath.NewInt(1000)
|
2022-01-08 00:39:27 +00:00
|
|
|
// if tokenABalance.LT(oneThousand) || tokenBBalance.LT(oneThousand) {
|
|
|
|
|
// return errorNotEnoughCoins
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// return nil
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // findValidAccountAllowedPoolPair finds an account for which the callback func returns true
|
|
|
|
|
// func findValidAccountAllowedPoolPair(accounts []simulation.Account, pools types.AllowedPools,
|
|
|
|
|
// cb func(simulation.Account, types.AllowedPool) bool) (simulation.Account, types.AllowedPool, bool) {
|
|
|
|
|
// for _, pool := range pools {
|
|
|
|
|
// for _, acc := range accounts {
|
|
|
|
|
// if isValid := cb(acc, pool); isValid {
|
|
|
|
|
// return acc, pool, true
|
|
|
|
|
// }
|
|
|
|
|
// }
|
|
|
|
|
// }
|
|
|
|
|
// return simulation.Account{}, types.AllowedPool{}, false
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// // findValidAccountPoolRecordPair finds an account for which the callback func returns true
|
|
|
|
|
// func findValidAccountPoolRecordPair(accounts []simulation.Account, pools types.PoolRecords,
|
|
|
|
|
// cb func(simulation.Account, types.PoolRecord) bool) (simulation.Account, types.PoolRecord, bool) {
|
|
|
|
|
// for _, pool := range pools {
|
|
|
|
|
// for _, acc := range accounts {
|
|
|
|
|
// if isValid := cb(acc, pool); isValid {
|
|
|
|
|
// return acc, pool, true
|
|
|
|
|
// }
|
|
|
|
|
// }
|
|
|
|
|
// }
|
|
|
|
|
// return simulation.Account{}, types.PoolRecord{}, false
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// func genRandDeadline(r *rand.Rand, blockTime time.Time) int64 {
|
|
|
|
|
// // Set up deadline
|
|
|
|
|
// durationNanoseconds, err := RandIntInclusive(r,
|
2023-04-05 23:21:59 +00:00
|
|
|
// sdkmath.NewInt((time.Second * 10).Nanoseconds()), // ten seconds
|
|
|
|
|
// sdkmath.NewInt((time.Hour * 24).Nanoseconds()), // one day
|
2022-01-08 00:39:27 +00:00
|
|
|
// )
|
|
|
|
|
// if err != nil {
|
|
|
|
|
// panic(err)
|
|
|
|
|
// }
|
|
|
|
|
// extraTime := time.Duration(durationNanoseconds.Int64())
|
|
|
|
|
// return blockTime.Add(extraTime).Unix()
|
|
|
|
|
// }
|
|
|
|
|
|
2023-04-05 23:21:59 +00:00
|
|
|
// // RandIntInclusive randomly generates an sdkmath.Int in the range [inclusiveMin, inclusiveMax]. It works for negative and positive integers.
|
|
|
|
|
// func RandIntInclusive(r *rand.Rand, inclusiveMin, inclusiveMax sdkmath.Int) (sdkmath.Int, error) {
|
2022-01-08 00:39:27 +00:00
|
|
|
// if inclusiveMin.GT(inclusiveMax) {
|
2023-04-05 23:21:59 +00:00
|
|
|
// return sdkmath.Int{}, fmt.Errorf("min larger than max")
|
2022-01-08 00:39:27 +00:00
|
|
|
// }
|
|
|
|
|
// return RandInt(r, inclusiveMin, inclusiveMax.Add(sdk.OneInt()))
|
|
|
|
|
// }
|
|
|
|
|
|
2023-04-05 23:21:59 +00:00
|
|
|
// // RandInt randomly generates an sdkmath.Int in the range [inclusiveMin, exclusiveMax). It works for negative and positive integers.
|
|
|
|
|
// func RandInt(r *rand.Rand, inclusiveMin, exclusiveMax sdkmath.Int) (sdkmath.Int, error) {
|
2022-01-08 00:39:27 +00:00
|
|
|
// // validate input
|
|
|
|
|
// if inclusiveMin.GTE(exclusiveMax) {
|
2023-04-05 23:21:59 +00:00
|
|
|
// return sdkmath.Int{}, fmt.Errorf("min larger or equal to max")
|
2022-01-08 00:39:27 +00:00
|
|
|
// }
|
|
|
|
|
// // shift the range to start at 0
|
|
|
|
|
// shiftedRange := exclusiveMax.Sub(inclusiveMin) // should always be positive given the check above
|
|
|
|
|
// // randomly pick from the shifted range
|
2023-04-05 23:21:59 +00:00
|
|
|
// shiftedRandInt := sdkmath.NewIntFromBigInt(new(big.Int).Rand(r, shiftedRange.BigInt()))
|
2022-01-08 00:39:27 +00:00
|
|
|
// // shift back to the original range
|
|
|
|
|
// return shiftedRandInt.Add(inclusiveMin), nil
|
|
|
|
|
// }
|