Skip to content

Commit

Permalink
Merge pull request #65 from meTokens/chore/del-inverse-views
Browse files Browse the repository at this point in the history 
chore(curve): remove calculateAssetsDeposited() views
  • Loading branch information
Carl Farterson authored Dec 7, 2021
2 parents e002f36 + 47897e3 commit 1028f1e
Show file tree
Hide file tree
Showing 8 changed files with 73 additions and 475 deletions.
51 changes: 0 additions & 51 deletions contracts/Foundry.sol
View file
Original file line number Diff line number Diff line change
Expand Up @@ -256,57 +256,6 @@ contract Foundry is IFoundry, Ownable, Initializable {
);
}

function calculateAssetsDeposited(
// TODO: can we just pass in hubId instead of _meToken for first argument?
address _meToken,
uint256 _desiredMeTokensMinted
) external view returns (uint256 assetsDeposited) {
Details.MeToken memory meToken_ = meTokenRegistry.getDetails(_meToken);
Details.Hub memory hub_ = hub.getDetails(meToken_.hubId);
// gas savings
uint256 totalSupply_ = IERC20(_meToken).totalSupply();

// Calculate return assuming update is not happening
assetsDeposited = ICurve(hub_.curve).viewAssetsDeposited(
_desiredMeTokensMinted,
meToken_.hubId,
totalSupply_,
meToken_.balancePooled
);
// Logic for if we're switching to a new curve type // updating curveDetails
if (
(hub_.updating && (hub_.targetCurve != address(0))) ||
(hub_.reconfigure)
) {
uint256 targetAssetsDeposited;
if (hub_.targetCurve != address(0)) {
// Means we are updating to a new curve type
targetAssetsDeposited = ICurve(hub_.targetCurve)
.viewAssetsDeposited(
_desiredMeTokensMinted,
meToken_.hubId,
totalSupply_,
meToken_.balancePooled
);
} else {
// Must mean we're updating curveDetails
targetAssetsDeposited = ICurve(hub_.curve)
.viewTargetAssetsDeposited(
_desiredMeTokensMinted,
meToken_.hubId,
totalSupply_,
meToken_.balancePooled
);
}
assetsDeposited = WeightedAverage.calculate(
assetsDeposited,
targetAssetsDeposited,
hub_.startTime,
hub_.endTime
);
}
}

// NOTE: for now this does not include fees
function calculateMeTokensMinted(address _meToken, uint256 _assetsDeposited)
public
Expand Down
128 changes: 0 additions & 128 deletions contracts/curves/BancorABDK.sol
View file
Original file line number Diff line number Diff line change
Expand Up @@ -183,54 +183,6 @@ contract BancorABDK is ICurve {
);
}

function viewAssetsDeposited(
uint256 _desiredMeTokens,
uint256 _hubId,
uint256 _supply,
uint256 _balancePooled
) external view override returns (uint256 assetsDeposited) {
Bancor memory bancor_ = _bancors[_hubId];
if (_supply > 0) {
assetsDeposited = _viewAssetsDeposited(
_desiredMeTokens,
bancor_.reserveWeight,
_supply,
bancor_.baseY,
_balancePooled
);
} else {
assetsDeposited = _viewAssetsDepositedFromZero(
_desiredMeTokens,
bancor_.reserveWeight,
bancor_.baseY
);
}
}

function viewTargetAssetsDeposited(
uint256 _desiredMeTokens,
uint256 _hubId,
uint256 _supply,
uint256 _balancePooled
) external view override returns (uint256 assetsDeposited) {
Bancor memory bancor_ = _bancors[_hubId];
if (_supply > 0) {
assetsDeposited = _viewAssetsDeposited(
_desiredMeTokens,
bancor_.targetReserveWeight,
_supply,
bancor_.targetBaseY,
_balancePooled
);
} else {
assetsDeposited = _viewAssetsDepositedFromZero(
_desiredMeTokens,
bancor_.targetReserveWeight,
bancor_.targetBaseY
);
}
}

///************************* CALCULATE FUNCTIONS **************************/
///**************** - USED BY MINT & BURN IN FOUNDRY.SOL - ****************/

Expand Down Expand Up @@ -390,84 +342,4 @@ contract BancorABDK is ICurve {
);
return res.toUInt();
}

///*************************** VIEW FUNCTIONS *****************************/
///******* - USED FOR ORACLES & THE FRONT END VIA FOUNDRY.SOL - ***********/

// VIEW COLLATERAL FOR DESIRED MINT
/***************************************************************************
// __ __ //
// T = tokensToDeposit / \ //
// d = desiredMeTokensMinted | y * rW | //
// rW = reserveWeight T = | -------------- | - bP //
// bP = balancePooled | x * (S + d)^2 | //
// S = supply \__ __/ //
// x = baseX //
// y = baseY //
// //
***************************************************************************/

// baseY * (supply + desiredMeTokens)^2 * reserveWeight / baseX - balancePooled
// or (baseY * reserveWeight) / baseX * (supply + desiredMeTokens)^2 - balancePooled
function _viewAssetsDeposited(
uint256 _desiredMeTokens,
uint256 _reserveWeight,
uint256 _supply,
uint256 _baseY,
uint256 _balancePooled
) private view returns (uint256) {
// TODO: does this need to be divided?
bytes16 reserveWeight = _reserveWeight.fromUInt().div(_maxWeight);
bytes16 k = _baseY.fromUInt().mul(reserveWeight).div(_baseX);
bytes16 squared = (_supply + _desiredMeTokens)
.fromUInt()
.ln()
.mul(uint256(2).fromUInt())
.exp();
bytes16 res = k.mul(squared).sub(_balancePooled.fromUInt());
return res.toUInt();
}

// VIEW COLLATERAL FOR DESIRED MINT (FROM ZERO)
/***************************************************************************
// //
// T = tokensToDeposit //
// d = desiredMeTokensMinted y * rW //
// rW = reserveWeight T = --------- //
// x = baseX x * d^2 //
// y = baseY //
// //
***************************************************************************/

// (baseY * desiredMeTokens^2 * reserveWeight) / baseX
// Or (baseY * reserveWeight) / baseX * desiredMeTokens^2
function _viewAssetsDepositedFromZero(
uint256 _desiredMeTokens,
uint256 _reserveWeight,
uint256 _baseY
) private view returns (uint256) {
bytes16 reserveWeight = _reserveWeight.fromUInt().div(_maxWeight);
bytes16 desiredMeTokens = _desiredMeTokens.fromUInt();
bytes16 res = _baseY
.fromUInt()
.div(_baseX)
.mul(reserveWeight)
.mul(desiredMeTokens.div(_baseX))
.mul(desiredMeTokens.div(_baseX));

return res.mul(_baseX).toUInt();
}

// VIEW BURN FOR DESIRED COLLATERAL RETURNED
/***************************************************************************
// __ __ //
// T = meTokensToBurn / \ //
// d = desiredCollateraReturned | | //
// rW = reserveWeight T = | ---------- | //
// bP = balancePooled | | //
// S = supply \__ __/ //
// //
***************************************************************************/

// TODO: Create function
}
84 changes: 0 additions & 84 deletions contracts/curves/BancorPower.sol
View file
Original file line number Diff line number Diff line change
Expand Up @@ -182,54 +182,6 @@ contract BancorPower is Power, ICurve {
);
}

function viewAssetsDeposited(
uint256 _desiredMeTokens,
uint256 _hubId,
uint256 _supply,
uint256 _balancePooled
) external view override returns (uint256 assetsDeposited) {
Bancor memory bancor_ = _bancors[_hubId];
if (_supply > 0) {
assetsDeposited = _viewAssetsDeposited(
_desiredMeTokens,
bancor_.reserveWeight,
_supply,
bancor_.baseY,
_balancePooled
);
} else {
assetsDeposited = _viewAssetsDepositedFromZero(
_desiredMeTokens,
bancor_.reserveWeight,
bancor_.baseY
);
}
}

function viewTargetAssetsDeposited(
uint256 _desiredMeTokens,
uint256 _hubId,
uint256 _supply,
uint256 _balancePooled
) external view override returns (uint256 assetsDeposited) {
Bancor memory bancor_ = _bancors[_hubId];
if (_supply > 0) {
assetsDeposited = _viewAssetsDeposited(
_desiredMeTokens,
bancor_.targetReserveWeight,
_supply,
bancor_.targetBaseY,
_balancePooled
);
} else {
assetsDeposited = _viewAssetsDepositedFromZero(
_desiredMeTokens,
bancor_.targetReserveWeight,
bancor_.targetBaseY
);
}
}

function _viewMeTokensMinted(
uint256 _depositAmount,
uint32 _connectorWeight,
Expand Down Expand Up @@ -330,40 +282,4 @@ contract BancorPower is Power, ICurve {
uint256 newBalance = _connectorBalance << precision;
return (oldBalance - newBalance) / result;
}

function _viewAssetsDepositedFromZero(
uint256 _desiredMeTokens,
uint256 _reserveWeight,
uint256 _baseY
) private view returns (uint256) {
bytes16 reserveWeight = _reserveWeight.fromUInt().div(_maxWeight);
bytes16 numerator = _baseY.fromUInt().mul(reserveWeight);
// Instead of calculating s ^ exp, we calculate e ^ (log(s) * exp).
bytes16 squared = _desiredMeTokens
.fromUInt()
.ln()
.mul(uint256(2).fromUInt())
.exp();
bytes16 res = numerator.mul(squared).div(_baseX);
return res.toUInt();
}

function _viewAssetsDeposited(
uint256 _desiredMeTokens,
uint256 _reserveWeight,
uint256 _supply,
uint256 _baseY,
uint256 _balancePooled
) private view returns (uint256) {
// TODO: does this need to be divided?
bytes16 reserveWeight = _reserveWeight.fromUInt().div(_maxWeight);
bytes16 k = _baseY.fromUInt().mul(reserveWeight).div(_baseX);
bytes16 squared = (_supply + _desiredMeTokens)
.fromUInt()
.ln()
.mul(uint256(2).fromUInt())
.exp();
bytes16 res = k.mul(squared).sub(_balancePooled.fromUInt());
return res.toUInt();
}
}
54 changes: 0 additions & 54 deletions contracts/curves/StepwiseCurve.sol
View file
Original file line number Diff line number Diff line change
Expand Up @@ -169,38 +169,6 @@ contract StepwiseCurve is ICurve {
);
}

function viewAssetsDeposited(
uint256 _desiredMeTokensMinted,
uint256 _hubId, // hubId
uint256 _supply, // current supply
uint256 _balancePooled
) external view override returns (uint256 assetsDeposited) {
Stepwise memory stepwiseDetails = _stepwises[_hubId];
assetsDeposited = _viewAssetsDeposited(
_desiredMeTokensMinted,
stepwiseDetails.stepX,
stepwiseDetails.stepY,
_supply,
_balancePooled
);
}

function viewTargetAssetsDeposited(
uint256 _desiredMeTokensMinted,
uint256 _hubId, // hubId
uint256 _supply, // current supply
uint256 _balancePooled
) external view override returns (uint256 assetsDeposited) {
Stepwise memory stepwiseDetails = _stepwises[_hubId];
assetsDeposited = _viewAssetsDeposited(
_desiredMeTokensMinted,
stepwiseDetails.targetStepX,
stepwiseDetails.targetStepY,
_supply,
_balancePooled
);
}

/// @notice Given a deposit (in the connector token), length of stepX, height of stepY, meToken supply and
/// balance pooled, calculate the return for a given conversion (in the meToken)
/// @param _assetsDeposited, // assets deposited
Expand Down Expand Up @@ -295,26 +263,4 @@ contract StepwiseCurve is ICurve {
supplyAtStepAfterBurn *
_stepY;
}

function _viewAssetsDeposited(
uint256 _desiredMeTokensMinted, // desired meTokens Minted
uint256 _stepX, // length of step (aka supply duration)
uint256 _stepY, // height of step (aka price delta)
uint256 _supply, // current supply
uint256 _balancePooled // current collateral amount
) private pure returns (uint256) {
uint256 stepsAfterMint = (_supply + _desiredMeTokensMinted) / _stepX;
uint256 stepSupplyAfterMint = _supply - (stepsAfterMint * _stepX);
uint256 stepBalanceAfterMint = ((stepsAfterMint *
stepsAfterMint +
stepsAfterMint) / 2) *
_stepX *
_stepY;

return
stepBalanceAfterMint +
stepSupplyAfterMint *
_stepY -
_balancePooled;
}
}
Loading

0 comments on commit 1028f1e

Please sign in to comment.