[CL][e2e]: CreateConcentratedPosition

tests/e2e/configurer/chain/chain.go

@@ -214,6 +214,11 @@ func (c *Config) GetPersistentPeers() []string {
 	return peers
 }
 
+// Returns the nodeIndex'th node on the chain
+func (c *Config) GetNodeAtIndex(nodeIndex int) (*NodeConfig, error) {
+	return c.getNodeAtIndex(nodeIndex)
+}
+
 func (c *Config) getNodeAtIndex(nodeIndex int) (*NodeConfig, error) {
 	if nodeIndex > len(c.NodeConfigs) {
 		return nil, fmt.Errorf("node index (%d) is greter than the number of nodes available (%d)", nodeIndex, len(c.NodeConfigs))

tests/e2e/configurer/chain/commands.go

@@ -11,6 +11,7 @@ import (
 
 	appparams "github.com/osmosis-labs/osmosis/v14/app/params"
 	"github.com/osmosis-labs/osmosis/v14/tests/e2e/configurer/config"
+	"github.com/osmosis-labs/osmosis/v14/tests/e2e/initialization"
 	"github.com/osmosis-labs/osmosis/v14/tests/e2e/util"
 
 	lockuptypes "github.com/osmosis-labs/osmosis/v14/x/lockup/types"
@@ -42,6 +43,16 @@ func (n *NodeConfig) CreateConcentratedPool(from, denom1, denom2 string, tickSpa
 	return poolID
 }
 
+func (n *NodeConfig) CreateConcentratedPosition(from, lowerTick, upperTick string, token0, token1 string, token0MinAmt, token1MinAmt int64, frozenUntil int64, poolId uint64) {
+	n.LogActionF("creating concentrated position")
+
+	cmd := []string{"osmosisd", "tx", "concentratedliquidity", "create-position", lowerTick, upperTick, token0, token1, fmt.Sprintf("%d", token0MinAmt), fmt.Sprintf("%d", token1MinAmt), fmt.Sprintf("%v", frozenUntil), fmt.Sprintf("--from=%s", from), fmt.Sprintf("--pool-id=%d", poolId)}
+	_, _, err := n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
+	require.NoError(n.t, err)
+
+	n.LogActionF("successfully created concentrated position from %s to %s", lowerTick, upperTick)
+}
+
 func (n *NodeConfig) StoreWasmCode(wasmFile, from string) {
 	n.LogActionF("storing wasm code from file %s", wasmFile)
 	cmd := []string{"osmosisd", "tx", "wasm", "store", wasmFile, fmt.Sprintf("--from=%s", from), "--gas=auto", "--gas-prices=0.1uosmo", "--gas-adjustment=1.3"}
@@ -271,6 +282,18 @@ func (n *NodeConfig) CreateWallet(walletName string) string {
 	return walletAddr
 }
 
+func (n *NodeConfig) CreateWalletAndFund(walletName string, tokensToFund []string) string {
+	n.LogActionF("Sending tokens to %s", walletName)
+
+	walletAddr := n.CreateWallet(walletName)
+	for _, tokenToFund := range tokensToFund {
+		n.BankSend(tokenToFund, initialization.ValidatorWalletName, walletAddr)
+	}
+
+	n.LogActionF("Successfully sent tokens to %s", walletName)
+	return walletAddr
+}
+
 func (n *NodeConfig) GetWallet(walletName string) string {
 	n.LogActionF("retrieving wallet %s", walletName)
 	cmd := []string{"osmosisd", "keys", "show", walletName, "--keyring-backend=test"}

tests/e2e/configurer/chain/queries.go

@@ -88,6 +88,17 @@ func (n *NodeConfig) QueryNumPools() uint64 {
 	return numPools.NumPools
 }
 
+func (n *NodeConfig) QueryConcentratedPositions(address string) []cltypes.FullPositionByOwnerResult {
+	path := fmt.Sprintf("/osmosis/concentratedliquidity/v1beta1/positions/%s", address)
+
+	bz, err := n.QueryGRPCGateway(path)
+	require.NoError(n.t, err)
+
+	var positionsResponse cltypes.QueryUserPositionsResponse
+	err = util.Cdc.UnmarshalJSON(bz, &positionsResponse)
+	require.NoError(n.t, err)
+	return positionsResponse.Positions
+}
 func (n *NodeConfig) QueryConcentratedPool(poolId uint64) (cltypes.ConcentratedPoolExtension, error) {
 	path := fmt.Sprintf("/osmosis/concentratedliquidity/v1beta1/pools/%d", poolId)
 	bz, err := n.QueryGRPCGateway(path)

tests/e2e/containers/config.go

@@ -24,7 +24,7 @@ const (
 	// It should be uploaded to Docker Hub. OSMOSIS_E2E_SKIP_UPGRADE should be unset
 	// for this functionality to be used.
 	previousVersionOsmoRepository = "osmolabs/osmosis-dev"
-	previousVersionOsmoTag        = "v14.x-de392d2b-1674667154"
+	previousVersionOsmoTag        = "v14.x-6b742c84-1675172347"
 	// Pre-upgrade repo/tag for osmosis initialization (this should be one version below upgradeVersion)
 	previousVersionInitRepository = "osmolabs/osmosis-e2e-init-chain"
 	previousVersionInitTag        = "v14.x-f6813bcb-1674140667-manual"

tests/e2e/e2e_test.go

@@ -14,6 +14,7 @@ import (
 
 	paramsutils "github.com/cosmos/cosmos-sdk/x/params/client/utils"
 
+	"github.com/osmosis-labs/osmosis/v14/x/concentrated-liquidity/types"
 	ibcratelimittypes "github.com/osmosis-labs/osmosis/v14/x/ibc-rate-limit/types"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -23,23 +24,25 @@ import (
 	appparams "github.com/osmosis-labs/osmosis/v14/app/params"
 	"github.com/osmosis-labs/osmosis/v14/tests/e2e/configurer/config"
 	"github.com/osmosis-labs/osmosis/v14/tests/e2e/initialization"
+	cl "github.com/osmosis-labs/osmosis/v14/x/concentrated-liquidity"
 )
 
 func (s *IntegrationTestSuite) TestConcentratedLiquidity() {
 	chainA := s.configurer.GetChainConfig(0)
-	node1, err := chainA.GetDefaultNode()
+	node, err := chainA.GetDefaultNode()
 	s.Require().NoError(err)
 
 	var (
 		denom0                    string = "uion"
 		denom1                    string = "uosmo"
 		tickSpacing               uint64 = 1
 		precisionFactorAtPriceOne int64  = -1
+		frozenUntil               int64  = time.Unix(86400, 0).Unix()
 		swapFee                          = "0.01"
 	)
-	poolID := node1.CreateConcentratedPool(initialization.ValidatorWalletName, denom0, denom1, tickSpacing, precisionFactorAtPriceOne, swapFee)
+	poolID := node.CreateConcentratedPool(initialization.ValidatorWalletName, denom0, denom1, tickSpacing, precisionFactorAtPriceOne, swapFee)
 
-	concentratedPool, err := node1.QueryConcentratedPool(poolID)
+	concentratedPool, err := node.QueryConcentratedPool(poolID)
 	s.Require().NoError(err)
 
 	// assert contents of the pool are valid
@@ -49,6 +52,64 @@ func (s *IntegrationTestSuite) TestConcentratedLiquidity() {
 	s.Require().Equal(concentratedPool.GetTickSpacing(), tickSpacing)
 	s.Require().Equal(concentratedPool.GetPrecisionFactorAtPriceOne(), sdk.NewInt(precisionFactorAtPriceOne))
 	s.Require().Equal(concentratedPool.GetSwapFee(sdk.Context{}), sdk.MustNewDecFromStr(swapFee))
+
+	minTick, maxTick := cl.GetMinAndMaxTicksFromExponentAtPriceOne(sdk.NewInt(precisionFactorAtPriceOne))
+
+	fundTokens := []string{"1000000uosmo", "1000000uion", "1000000stake"}
+	// get 3 addresses to create positions
+	address1 := node.CreateWalletAndFund("addr1", fundTokens)
+	address2 := node.CreateWalletAndFund("addr2", fundTokens)
+	address3 := node.CreateWalletAndFund("addr3", fundTokens)
+
+	// Create 2 positions for node1: overlap together, overlap with 2 node3 positions)
+	node.CreateConcentratedPosition(address1, "[-1200]", "400", fmt.Sprintf("1000%s", denom0), fmt.Sprintf("1000%s", denom1), 0, 0, frozenUntil, poolID)
+	node.CreateConcentratedPosition(address1, "[-400]", "400", fmt.Sprintf("1000%s", denom0), fmt.Sprintf("1000%s", denom1), 0, 0, frozenUntil, poolID)
+
+	// Create 1 position for node2: does not overlap with anything, ends at maximum
+	node.CreateConcentratedPosition(address2, "2200", fmt.Sprintf("%d", maxTick), fmt.Sprintf("1000%s", denom0), fmt.Sprintf("1000%s", denom1), 0, 0, frozenUntil, poolID)
+
+	// Create 2 positions for node3: overlap together, overlap with 2 node1 positions, one position starts from minimum
+	node.CreateConcentratedPosition(address3, "[-1600]", "[-200]", fmt.Sprintf("1000%s", denom0), fmt.Sprintf("1000%s", denom1), 0, 0, frozenUntil, poolID)
+	node.CreateConcentratedPosition(address3, fmt.Sprintf("[%d]", minTick), "1400", fmt.Sprintf("1000%s", denom0), fmt.Sprintf("1000%s", denom1), 0, 0, frozenUntil, poolID)
+
+	// get newly created positions
+	positionsAddress1 := node.QueryConcentratedPositions(address1)
+	positionsAddress2 := node.QueryConcentratedPositions(address2)
+	positionsAddress3 := node.QueryConcentratedPositions(address3)
+
+	// assert number of positions per address
+	s.Require().Equal(len(positionsAddress1), 2)
+	s.Require().Equal(len(positionsAddress2), 1)
+	s.Require().Equal(len(positionsAddress3), 2)
+
+	// Assert returned positions:
+
+	validateCLPosition := func(position types.FullPositionByOwnerResult, poolId uint64, lowerTick, upperTick int64) {
+		s.Require().Equal(position.PoolId, poolId)
+		s.Require().Equal(position.LowerTick, int64(lowerTick))
+		s.Require().Equal(position.UpperTick, int64(upperTick))
+	}
+
+	// assert positions for address1
+	a1p1 := positionsAddress1[0]
+	a1p2 := positionsAddress1[1]
+	// first position first address
+	validateCLPosition(a1p1, poolID, -1200, 400)
+	// second position second address
+	validateCLPosition(a1p2, poolID, -400, 400)
+
+	// assert positions for address2
+	a2p1 := positionsAddress2[0]
+	// first position second address
+	validateCLPosition(a2p1, poolID, 2200, maxTick)
+
+	// assert positions for address3
+	a3p1 := positionsAddress3[0]
+	a3p2 := positionsAddress3[1]
+	// first position third address
+	validateCLPosition(a3p1, poolID, -1600, -200)
+	// second position third address
+	validateCLPosition(a3p2, poolID, minTick, 1400)
 }
 
 // TestGeometricTwapMigration tests that the geometric twap record

x/concentrated-liquidity/grpc_query.go

@@ -58,7 +58,10 @@ func (q Querier) UserPositions(ctx context.Context, req *types.QueryUserPosition
 	}
 
 	sdkCtx := sdk.UnwrapSDKContext(ctx)
-	sdkAddr := sdk.AccAddress(req.Address)
+	sdkAddr, err := sdk.AccAddressFromBech32(req.Address)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
 
 	userPositions, err := q.Keeper.GetUserPositions(sdkCtx, sdkAddr)
 	if err != nil {