Master (#1262)

* clear

* feat: Add everything

* fix: Commenht

x/dex/keeper/portfolio.go

@@ -0,0 +1,216 @@
+// Package keeper implements the dex module keeper
+package keeper
+
+import (
+	"fmt"
+
+	"cosmossdk.io/math"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// Portfolio represents a user's portfolio across chains
+type Portfolio struct {
+	DID         string
+	Connections []string
+	Balances    map[string]sdk.Coins // connectionID -> balances
+	Positions   map[string]*Position // positionID -> position
+	TotalValue  math.LegacyDec
+	UpdatedAt   int64
+}
+
+// Position represents a liquidity or staking position
+type Position struct {
+	PositionID   string
+	ConnectionID string
+	PoolID       uint64
+	Type         PositionType
+	Shares       math.Int
+	Value        sdk.Coins
+	APR          math.LegacyDec
+	CreatedAt    int64
+}
+
+// PositionType represents the type of position
+type PositionType int
+
+const (
+	PositionTypeLiquidity PositionType = iota
+	PositionTypeStaking
+	PositionTypeLending
+	PositionTypeBorrowing
+)
+
+// GetPortfolio retrieves the complete portfolio for a DID
+func (k Keeper) GetPortfolio(
+	ctx sdk.Context,
+	did string,
+) (*Portfolio, error) {
+	// Get all DEX accounts for this DID
+	accounts, err := k.GetDEXAccountsByDID(ctx, did)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get DEX accounts: %w", err)
+	}
+
+	portfolio := &Portfolio{
+		DID:         did,
+		Connections: make([]string, 0),
+		Balances:    make(map[string]sdk.Coins),
+		Positions:   make(map[string]*Position),
+		TotalValue:  math.LegacyZeroDec(),
+		UpdatedAt:   ctx.BlockTime().Unix(),
+	}
+
+	// Collect connections
+	for _, account := range accounts {
+		portfolio.Connections = append(portfolio.Connections, account.ConnectionId)
+
+		// Get balances for each connection
+		balances, err := k.GetRemoteBalances(ctx, did, account.ConnectionId)
+		if err == nil {
+			portfolio.Balances[account.ConnectionId] = balances
+		}
+	}
+
+	// Calculate total value (simplified - would need price feeds)
+	portfolio.TotalValue = k.CalculatePortfolioValue(ctx, portfolio.Balances)
+
+	return portfolio, nil
+}
+
+// GetRemoteBalances queries balances on a remote chain
+func (k Keeper) GetRemoteBalances(
+	ctx sdk.Context,
+	did string,
+	connectionID string,
+) (sdk.Coins, error) {
+	// This would query the remote chain for balances
+	// For now, return placeholder balances
+	return sdk.NewCoins(
+		sdk.NewCoin("uatom", math.NewInt(1000000)),
+		sdk.NewCoin("uosmo", math.NewInt(2000000)),
+	), nil
+}
+
+// GetPositions retrieves all positions for a DID
+func (k Keeper) GetPositions(
+	ctx sdk.Context,
+	did string,
+	connectionID string,
+) ([]*Position, error) {
+	// This would query positions from remote chain
+	// For now, return empty list
+	return []*Position{}, nil
+}
+
+// CalculatePortfolioValue calculates the total portfolio value
+func (k Keeper) CalculatePortfolioValue(
+	ctx sdk.Context,
+	balances map[string]sdk.Coins,
+) math.LegacyDec {
+	// This would use price feeds to calculate USD value
+	// For now, return a simple sum of amounts
+	totalValue := math.LegacyZeroDec()
+
+	for _, coins := range balances {
+		for _, coin := range coins {
+			// Simplified: assume 1:1 USD value
+			totalValue = totalValue.Add(math.LegacyNewDecFromInt(coin.Amount))
+		}
+	}
+
+	return totalValue
+}
+
+// GetPortfolioHistory retrieves historical portfolio data
+func (k Keeper) GetPortfolioHistory(
+	ctx sdk.Context,
+	did string,
+	startTime int64,
+	endTime int64,
+) ([]*PortfolioSnapshot, error) {
+	// This would retrieve historical snapshots from state
+	// For now, return empty list
+	return []*PortfolioSnapshot{}, nil
+}
+
+// PortfolioSnapshot represents a point-in-time portfolio state
+type PortfolioSnapshot struct {
+	Timestamp  int64
+	TotalValue math.LegacyDec
+	Balances   map[string]sdk.Coins
+	Positions  int
+}
+
+// UpdatePortfolioSnapshot creates a new portfolio snapshot
+func (k Keeper) UpdatePortfolioSnapshot(
+	ctx sdk.Context,
+	did string,
+) error {
+	portfolio, err := k.GetPortfolio(ctx, did)
+	if err != nil {
+		return fmt.Errorf("failed to get portfolio: %w", err)
+	}
+
+	snapshot := &PortfolioSnapshot{
+		Timestamp:  ctx.BlockTime().Unix(),
+		TotalValue: portfolio.TotalValue,
+		Balances:   portfolio.Balances,
+		Positions:  len(portfolio.Positions),
+	}
+
+	// Store snapshot in state or DWN
+	// Implementation would depend on storage strategy
+	_ = snapshot
+
+	return nil
+}
+
+// GetPortfolioPerformance calculates portfolio performance metrics
+func (k Keeper) GetPortfolioPerformance(
+	ctx sdk.Context,
+	did string,
+	period int64, // Period in seconds
+) (*PerformanceMetrics, error) {
+	// This would calculate performance based on historical data
+	// For now, return placeholder metrics
+	return &PerformanceMetrics{
+		TotalReturn:    math.LegacyNewDec(10),             // 10% return
+		TotalReturnPct: math.LegacyNewDecWithPrec(10, 2),  // 10%
+		DailyReturn:    math.LegacyNewDec(1),              // 1% daily
+		APY:            math.LegacyNewDecWithPrec(365, 2), // 365% APY (simplified)
+		Volatility:     math.LegacyNewDecWithPrec(15, 2),  // 15% volatility
+		SharpeRatio:    math.LegacyNewDecWithPrec(2, 1),   // 2.0 Sharpe
+		MaxDrawdown:    math.LegacyNewDecWithPrec(5, 2),   // 5% max drawdown
+	}, nil
+}
+
+// PerformanceMetrics represents portfolio performance metrics
+type PerformanceMetrics struct {
+	TotalReturn    math.LegacyDec
+	TotalReturnPct math.LegacyDec
+	DailyReturn    math.LegacyDec
+	APY            math.LegacyDec
+	Volatility     math.LegacyDec
+	SharpeRatio    math.LegacyDec
+	MaxDrawdown    math.LegacyDec
+}
+
+// GetTopPerformers returns the top performing assets in portfolio
+func (k Keeper) GetTopPerformers(
+	ctx sdk.Context,
+	did string,
+	limit int,
+) ([]*AssetPerformance, error) {
+	// This would analyze asset performance
+	// For now, return empty list
+	return []*AssetPerformance{}, nil
+}
+
+// AssetPerformance represents performance of a single asset
+type AssetPerformance struct {
+	Asset      string
+	Connection string
+	Return     math.LegacyDec
+	ReturnPct  math.LegacyDec
+	Volume     math.Int
+}