pump stream 1

Author: keruch

x/iro/keeper/msg_server.go

@@ -56,7 +56,7 @@ func (m msgServer) BuyExactSpend(ctx context.Context, req *types.MsgBuyExactSpen
 		return nil, err
 	}
 
-	err = m.Keeper.BuyExactSpend(sdk.UnwrapSDKContext(ctx), req.PlanId, buyer, req.Spend, req.MinOutTokensAmount)
+	_, err = m.Keeper.BuyExactSpend(sdk.UnwrapSDKContext(ctx), req.PlanId, buyer, req.Spend, req.MinOutTokensAmount)
 	if err != nil {
 		return nil, err
 	}

x/iro/keeper/trade.go

@@ -115,53 +115,58 @@ func (k Keeper) Buy(ctx sdk.Context, planId string, buyer sdk.AccAddress, amount
 }
 
 // BuyExactSpend uses exact amount of liquidity to buy tokens on the curve
-func (k Keeper) BuyExactSpend(ctx sdk.Context, planId string, buyer sdk.AccAddress, amountToSpend, minTokensAmt math.Int) error {
+func (k Keeper) BuyExactSpend(
+	ctx sdk.Context,
+	planId string,
+	buyer sdk.AccAddress,
+	amountToSpend, minTokensAmt math.Int,
+) (tokensOutAmt math.Int, err error) {
 	plan, err := k.GetTradeableIRO(ctx, planId, buyer)
 	if err != nil {
-		return err
+		return math.ZeroInt(), err
 	}
 
 	// deduct taker fee from the amount to spend
 	toSpendMinusTakerFeeAmt, takerFeeAmt, err := k.ApplyTakerFee(amountToSpend, k.GetParams(ctx).TakerFee, false)
 	if err != nil {
-		return err
+		return math.ZeroInt(), err
 	}
 
 	// calculate the amount of tokens possible to buy with the amount to spend
-	tokensOutAmt, err := plan.BondingCurve.TokensForExactInAmount(plan.SoldAmt, toSpendMinusTakerFeeAmt)
+	tokensOutAmt, err = plan.BondingCurve.TokensForExactInAmount(plan.SoldAmt, toSpendMinusTakerFeeAmt)
 	if err != nil {
-		return err
+		return math.ZeroInt(), err
 	}
 
 	// Validate expected out amount
 	if tokensOutAmt.LT(minTokensAmt) {
-		return errorsmod.Wrapf(types.ErrInvalidMinCost, "minTokens: %s, tokens: %s, fee: %s", minTokensAmt.String(), tokensOutAmt.String(), takerFeeAmt.String())
+		return math.ZeroInt(), errorsmod.Wrapf(types.ErrInvalidMinCost, "minTokens: %s, tokens: %s, fee: %s", minTokensAmt.String(), tokensOutAmt.String(), takerFeeAmt.String())
 	}
 
 	// validate the IRO have enough tokens to sell
 	if plan.SoldAmt.Add(tokensOutAmt).GT(plan.MaxAmountToSell) {
-		return types.ErrInsufficientTokens
+		return math.ZeroInt(), types.ErrInsufficientTokens
 	}
 
 	// Charge taker fee
 	takerFee := sdk.NewCoin(plan.LiquidityDenom, takerFeeAmt)
 	owner := k.rk.MustGetRollappOwner(ctx, plan.RollappId)
 	err = k.chargeTakerFee(ctx, takerFee, buyer, &owner)
 	if err != nil {
-		return err
+		return math.ZeroInt(), err
 	}
 
 	// Send liquidity token from buyer to the plan. The liquidity token sent directly to the plan's module account
 	cost := sdk.NewCoin(plan.LiquidityDenom, toSpendMinusTakerFeeAmt)
 	err = k.BK.SendCoins(ctx, buyer, plan.GetAddress(), sdk.NewCoins(cost))
 	if err != nil {
-		return err
+		return math.ZeroInt(), err
 	}
 
 	// send allocated tokens from the plan to the buyer
 	err = k.BK.SendCoinsFromModuleToAccount(ctx, types.ModuleName, buyer, sdk.NewCoins(sdk.NewCoin(plan.TotalAllocation.Denom, tokensOutAmt)))
 	if err != nil {
-		return err
+		return math.ZeroInt(), err
 	}
 
 	// Update plan
@@ -179,10 +184,10 @@ func (k Keeper) BuyExactSpend(ctx sdk.Context, planId string, buyer sdk.AccAddre
 		ClosingPrice: plan.SpotPrice(),
 	})
 	if err != nil {
-		return err
+		return math.ZeroInt(), err
 	}
 
-	return nil
+	return tokensOutAmt, nil
 }
 
 // Sell sells allocation with price according to the price curve

x/streamer/keeper/keeper.go

@@ -31,6 +31,7 @@ type Keeper struct {
 	iroKeeper         types.IROKeeper
 	poolManagerKeeper types.PoolManagerKeeper
 	rollappKeeper     types.RollappKeeper
+	txFeesKeeper      types.TxFeesKeeper
 
 	authority string
 
@@ -51,6 +52,7 @@ func NewKeeper(
 	iroKeeper types.IROKeeper,
 	poolManagerKeeper types.PoolManagerKeeper,
 	rollappKeeper types.RollappKeeper,
+	txFeesKeeper types.TxFeesKeeper,
 	authority string,
 ) *Keeper {
 	sb := collections.NewSchemaBuilder(collcompat.NewKVStoreService(storeKey))
@@ -67,6 +69,7 @@ func NewKeeper(
 		iroKeeper:         iroKeeper,
 		poolManagerKeeper: poolManagerKeeper,
 		rollappKeeper:     rollappKeeper,
+		txFeesKeeper:      txFeesKeeper,
 		authority:         authority,
 		epochPointers: collections.NewMap(
 			sb,

x/streamer/keeper/pump_stream.go

@@ -13,29 +13,6 @@ import (
 	poolmanagertypes "github.com/osmosis-labs/osmosis/v15/x/poolmanager/types"
 )
 
-// ShouldExecutePump decides if the pump should happen in this block based on stream's pump params.
-func (k Keeper) ShouldExecutePump(ctx sdk.Context, stream types.Stream) (bool, error) {
-	if stream.PumpParams == nil {
-		return false, nil
-	}
-
-	if stream.PumpParams.EpochBudgetLeft.IsZero() {
-		return false, nil
-	}
-
-	epochBlocks, err := k.EpochBlocks(ctx, stream.DistrEpochIdentifier)
-	if err != nil {
-		return false, fmt.Errorf("failed to get epoch blocks: %w", err)
-	}
-
-	pumpAmt, err := ShouldPump(ctx, stream.PumpParams.EpochBudget, stream.PumpParams.EpochBudgetLeft, stream.PumpParams.NumPumps, epochBlocks)
-	if err != nil {
-		return false, fmt.Errorf("failed to calculate pump amount: %w", err)
-	}
-
-	return !pumpAmt.IsZero(), nil
-}
-
 // ShouldPump decides if the pump should happen in this block. It uses block
 // hash and block time as entropy.
 //
@@ -116,63 +93,73 @@ func (k Keeper) ExecutePump(
 	ctx sdk.Context,
 	pumpAmt math.Int,
 	rollappID string,
-) error {
+) (tokenOut sdk.Coin, err error) {
 	rollapp, found := k.rollappKeeper.GetRollapp(ctx, rollappID)
 	if !found {
-		return fmt.Errorf("rollapp not found: %s", rollappID)
+		return sdk.Coin{}, fmt.Errorf("rollapp not found: %s", rollappID)
 	}
 
 	plan, found := k.iroKeeper.GetPlanByRollapp(ctx, rollapp.RollappId)
 	if !found {
-		return fmt.Errorf("IRO plan not found for rollapp: %s", rollappID)
+		return sdk.Coin{}, fmt.Errorf("IRO plan not found for rollapp: %s", rollappID)
 	}
 
-	address := k.ak.GetModuleAddress(types.ModuleName)
-	// TODO: get base denom
-	baseDenom := "adym" // Base denom for budget
+	// Always use base denom for budget
+	baseDenom, err := k.txFeesKeeper.GetBaseDenom(ctx)
+	if err != nil {
+		return sdk.Coin{}, fmt.Errorf("get base denom: %w", err)
+	}
 
-	return osmoutils.ApplyFuncIfNoError(ctx, func(ctx sdk.Context) error {
-		var targetDenom string
-		if plan.IsSettled() {
-			targetDenom = plan.SettledDenom
-		} else {
-			targetDenom = plan.LiquidityDenom
-		}
+	var targetDenom string
+	if plan.IsSettled() {
+		targetDenom = plan.SettledDenom
+	} else {
+		targetDenom = plan.LiquidityDenom
+	}
 
-		// Get FeeToken for target denom to find routing
-		feeToken, err := k.getFeeTokenForDenom(ctx, targetDenom)
-		if err != nil {
-			return fmt.Errorf("get fee token for denom %s: %w", targetDenom, err)
-		}
+	// Get FeeToken for target denom to find routing to the base denom.
+	// Every token must have a route to the base denom.
+	feeToken, err := k.txFeesKeeper.GetFeeToken(ctx, targetDenom)
+	if err != nil {
+		return sdk.Coin{}, fmt.Errorf("get fee token for denom %s: %w", targetDenom, err)
+	}
 
-		tokenIn := sdk.NewCoin(baseDenom, pumpAmt)
+	buyer := k.ak.GetModuleAddress(types.ModuleName)
+	var tokenOutAmt math.Int
 
-		targetAmount, err := k.poolManagerKeeper.RouteExactAmountIn(
+	err = osmoutils.ApplyFuncIfNoError(ctx, func(ctx sdk.Context) error {
+		// Buy:
+		// - RA tokens if IRO is over
+		// - Liquidity tokens if IRO is in progress
+		tokenOutAmt, err := k.poolManagerKeeper.RouteExactAmountIn(
 			ctx,
-			address,
-			feeToken.Route, // Use route from FeeToken
-			tokenIn,
-			math.ZeroInt(), // tokenOutMinAmount = 0 (ignore slippage for now)
+			buyer,
+			feeToken.Route,
+			sdk.NewCoin(baseDenom, pumpAmt), // token in
+			math.ZeroInt(),                  // no slippage)
 		)
 		if err != nil {
 			return fmt.Errorf("route exact amount in: target denom: %s, error: %w", targetDenom, err)
 		}
 
 		if !plan.IsSettled() {
-			err = k.iroKeeper.BuyExactSpend(
+			// If IRO is in progress, use liquidity tokens to buy IRO tokens
+			tokenOutAmt, err = k.iroKeeper.BuyExactSpend(
 				ctx,
 				fmt.Sprintf("%d", plan.Id),
-				address,
-				targetAmount,   // amountToSpend
-				math.ZeroInt(), // minTokensAmt = 0
+				buyer,
+				tokenOutAmt,    // amountToSpend
+				math.ZeroInt(), // no slippage
 			)
 			if err != nil {
-				return fmt.Errorf("buy from IRO: %w", err)
+				return fmt.Errorf("buy from IRO %d: %w", plan.Id, err)
 			}
 		}
 
 		return nil
 	})
+
+	return sdk.NewCoin(targetDenom, tokenOutAmt), err
 }
 
 // getFeeTokenForDenom gets the FeeToken configuration for a given denom
@@ -210,33 +197,29 @@ func (k Keeper) DistributePumpStreams(ctx sdk.Context, pumpStreams []types.Strea
 		}
 
 		// Use ShouldPump directly to determine pump amount
-		pumpAmt, err := ShouldPump(ctx, stream.PumpParams.EpochBudget, stream.PumpParams.EpochBudgetLeft, stream.PumpParams.NumPumps, epochBlocks)
+		pumpAmt, err := ShouldPump(
+			ctx,
+			stream.PumpParams.EpochBudget,
+			stream.PumpParams.EpochBudgetLeft,
+			stream.PumpParams.NumPumps,
+			epochBlocks,
+		)
 		if err != nil {
 			return fmt.Errorf("failed to calculate pump amount: %w", err)
 		}
 
 		if pumpAmt.IsZero() {
+			// Shouldn't pump on this iteration
 			continue
 		}
 
 		// Get top rollapps from the stream's distribution
 		rollapps := k.TopRollapps(ctx, stream.DistributeTo.Records, stream.PumpParams.NumTopRollapps)
 
-		// Calculate total weight for proportional distribution
-		totalWeight := math.ZeroInt()
-		for _, rollapp := range rollapps {
-			totalWeight = totalWeight.Add(rollapp.Weight)
-		}
-
-		if totalWeight.IsZero() {
-			k.Logger(ctx).Info("no valid rollapps found for pump stream", "streamID", stream.Id)
-			continue
-		}
-
 		// Distribute pump amount proportionally to each rollapp
 		for _, rollapp := range rollapps {
 			// Calculate proportional pump amount based on rollapp weight
-			pumpAmtRA := pumpAmt.Mul(rollapp.Weight).Quo(totalWeight)
+			pumpAmtRA := pumpAmt.Mul(rollapp.Weight).Quo(stream.DistributeTo.TotalWeight)
 
 			if pumpAmtRA.IsZero() {
 				continue

x/streamer/types/expected_keepers.go

@@ -9,6 +9,7 @@ import (
 	minttypes "github.com/cosmos/cosmos-sdk/x/mint/types"
 	epochstypes "github.com/osmosis-labs/osmosis/v15/x/epochs/types"
 	poolmanagertypes "github.com/osmosis-labs/osmosis/v15/x/poolmanager/types"
+	txfeestypes "github.com/osmosis-labs/osmosis/v15/x/txfees/types"
 
 	incentivestypes "github.com/dymensionxyz/dymension/v3/x/incentives/types"
 	irotypes "github.com/dymensionxyz/dymension/v3/x/iro/types"
@@ -57,7 +58,7 @@ type MintParamsGetter interface {
 
 type IROKeeper interface {
 	GetPlanByRollapp(ctx sdk.Context, rollappId string) (irotypes.Plan, bool)
-	BuyExactSpend(ctx sdk.Context, planId string, buyer sdk.AccAddress, amountToSpend, minTokensAmt math.Int) error
+	BuyExactSpend(ctx sdk.Context, planId string, buyer sdk.AccAddress, amountToSpend, minTokensAmt math.Int) (math.Int, error)
 }
 
 type PoolManagerKeeper interface {
@@ -73,3 +74,8 @@ type PoolManagerKeeper interface {
 type RollappKeeper interface {
 	GetRollapp(ctx sdk.Context, rollappId string) (rollapptypes.Rollapp, bool)
 }
+
+type TxFeesKeeper interface {
+	GetFeeToken(ctx sdk.Context, denom string) (txfeestypes.FeeToken, error)
+	GetBaseDenom(ctx sdk.Context) (string, error)
+}