FLO-5: Consistent behaviour in withdrawAndPull/depositAndPush

[jordanschalm]

Closes #214

Previously, withdrawAndPull only triggered the top-up source when health dropped below minHealth, while depositAndPush always rebalanced to targetHealth. This asymmetry left positions between minHealth and targetHealth without rebalancing. Now both operations consistently rebalance to targetHealth when their respective flags are set.

[holyfuchs]

I think we can use this PR to clean this function up a bit.

The current implementation is using:
computationUsed (pull=true, no pull needed): 163
computationUsed (pull=true, pull executed): 199
computationUsed (pull=false): 128

The suggestion:
computationUsed (pull=true, no pull needed): 114
computationUsed (pull=true, pull executed): 136
computationUsed (pull=false): 64

effectively cutting execution used on pull=false by 50%.

[holyfuchs]

Suggested change

	pre {
	!self.isPausedOrWarmup(): "Withdrawals are paused by governance"
	self.positions[pid] != nil:
	"Invalid position ID \(pid) - could not find an InternalPosition with the requested ID in the Pool"
	self.state.getTokenState(type) != nil:
	"Invalid token type \(type.identifier) - not supported by this Pool"
	}
	post {
	!self.state.isPositionLocked(pid): "Position is not unlocked"
	}
	self.lockPosition(pid)
	if self.config.isDebugLogging() {
	log(" [CONTRACT] withdrawAndPull(pid: \(pid), type: \(type.identifier), amount: \(amount), pullFromTopUpSource: \(pullFromTopUpSource))")
	}
	if amount == 0.0 {
	self.unlockPosition(pid)
	return <- DeFiActionsUtils.getEmptyVault(type)
	}
	// Get a reference to the user's position and global token state for the affected token.
	let position = self._borrowPosition(pid: pid)
	let tokenState = self._borrowUpdatedTokenState(type: type)
	if pullFromTopUpSource {
	let topUpSource = position.borrowTopUpSource()
	let topUpType = topUpSource?.getSourceType() ?? self.state.getDefaultToken()
	let targetHealthDeposit = self.fundsRequiredForTargetHealthAfterWithdrawing(
	pid: pid,
	depositType: topUpType,
	targetHealth: position.getTargetHealth(),
	withdrawType: type,
	withdrawAmount: amount
	)
	if let topUpSource = topUpSource {
	let pulledVault <- topUpSource.withdrawAvailable(maxAmount: targetHealthDeposit)
	assert(pulledVault.getType() == topUpType, message: "topUpSource returned unexpected token type")
	self._depositEffectsOnly(
	pid: pid,
	from: <-pulledVault
	)
	}
	}
	if position.getBalance(type) == nil {
	position.setBalance(type, FlowALPModels.InternalBalance(
	direction: FlowALPModels.BalanceDirection.Credit,
	scaledBalance: 0.0
	))
	}
	// Reflect the withdrawal in the position's balance
	let uintAmount = UFix128(amount)
	position.borrowBalance(type)!.recordWithdrawal(
	amount: uintAmount,
	tokenState: tokenState
	)
	// Safety checks!
	self._assertMinimumBalanceAfterWithdrawal(type: type, position: position, tokenState: tokenState)
	let postHealth = self.positionHealth(pid: pid)
	if postHealth < position.getMinHealth() {
	if self.config.isDebugLogging() {
	let topUpType = position.borrowTopUpSource()?.getSourceType() ?? self.state.getDefaultToken()
	let minHealthDeposit = self.fundsRequiredForTargetHealthAfterWithdrawing(
	pid: pid,
	depositType: topUpType,
	targetHealth: position.getMinHealth(),
	withdrawType: type,
	withdrawAmount: amount
	)
	let availableBalance = self.availableBalance(pid: pid, type: type, pullFromTopUpSource: false)
	log(" [CONTRACT] WITHDRAWAL FAILED:")
	log(" [CONTRACT] Position ID: \(pid)")
	log(" [CONTRACT] Token type: \(type.identifier)")
	log(" [CONTRACT] Requested amount: \(amount)")
	log(" [CONTRACT] Available balance (without topUp): \(availableBalance)")
	log(" [CONTRACT] Required deposit for minHealth: \(minHealthDeposit)")
	log(" [CONTRACT] Pull from topUpSource: \(pullFromTopUpSource)")
	}
	// We can't service this withdrawal, so we just abort
	panic("Cannot withdraw \(amount) of \(type.identifier) from position ID \(pid) - Insufficient funds for withdrawal")
	}
	self._queuePositionForUpdateIfNecessary(pid: pid)
	let reserveVault = self.state.borrowReserve(type)!
	let withdrawn <- reserveVault.withdraw(amount: amount)
	FlowALPEvents.emitWithdrawn(
	pid: pid,
	poolUUID: self.uuid,
	vaultType: type,
	amount: withdrawn.balance,
	withdrawnUUID: withdrawn.uuid
	)
	self.unlockPosition(pid)
	return <- withdrawn
	}
	/// Asserts that the remaining balance of `type` meets the minimum per-position requirement
	/// (or is exactly zero). Panics with a descriptive message if not satisfied.
	access(self) view fun _assertMinimumBalanceAfterWithdrawal(
	type: Type,
	position: &{FlowALPModels.InternalPosition},
	tokenState: &{FlowALPModels.TokenState}
	) {
	let bal = position.getBalance(type)
	let remainingBalance: UFix128 = bal == nil ? 0.0
	: bal!.direction == FlowALPModels.BalanceDirection.Credit
	? FlowALPMath.scaledBalanceToTrueBalance(bal!.scaledBalance, interestIndex: tokenState.getCreditInterestIndex())
	: FlowALPMath.scaledBalanceToTrueBalance(bal!.scaledBalance, interestIndex: tokenState.getDebitInterestIndex())
	assert(
	remainingBalance == 0.0 || self.positionSatisfiesMinimumBalance(type: type, balance: remainingBalance),
	message: "Withdrawal would leave position below minimum balance requirement of \(self.state.getTokenState(type)!.getMinimumTokenBalancePerPosition()). Remaining balance would be \(remainingBalance)."
	)
	}