diff --git a/package.json b/package.json index 6128b26..8ff26fc 100644 --- a/package.json +++ b/package.json @@ -28,7 +28,7 @@ "scripts": { "build": "forge build", "clean": "rm -rf cache out", - "test": "forge test --no-match-path src/core/Lendgine.sol", + "test": "forge test --no-match-path src/core/squared.sol", "lint": "forge fmt", "lint:ci": "forge fmt --check", "lint:sol": "solhint \"{src,test}/**/*.sol\"", diff --git a/script/Deploy.s.sol b/script/Deploy.s.sol index 50ed0ef..900d86b 100644 --- a/script/Deploy.s.sol +++ b/script/Deploy.s.sol @@ -8,7 +8,7 @@ import { console2 } from "forge-std/console2.sol"; import { Factory } from "src/core/Factory.sol"; import { LiquidityManager } from "src/periphery/LiquidityManager.sol"; -import { LendgineRouter } from "src/periphery/LendgineRouter.sol"; +import { SquaredRouter } from "src/periphery/SquaredRouter.sol"; contract Deploy is Script { address constant create3Factory = 0x93FEC2C00BfE902F733B57c5a6CeeD7CD1384AE1; @@ -20,7 +20,7 @@ contract Deploy is Script { //Uniswap deployed WETH address constant weth = 0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14; - function run() external returns (address factory, address liquidityManager, address lendgineRouter) { + function run() external returns (address factory, address liquidityManager, address squaredRouter) { // CREATE3Factory create3 = CREATE3Factory(create3Factory); uint256 pk = vm.envUint("PRIVATE_KEY"); @@ -30,7 +30,7 @@ contract Deploy is Script { liquidityManager = address(new LiquidityManager(factory, weth)); - lendgineRouter = address(new LendgineRouter(factory, uniV2Factory, uniV3Factory, weth)); + squaredRouter = address(new SquaredRouter(factory, uniV2Factory, uniV3Factory, weth)); // factory = create2.deploy(keccak256("SquaredFactory"), type(Factory).creationCode); @@ -38,7 +38,7 @@ contract Deploy is Script { // keccak256("SquaredManager"), bytes.concat(type(LiquidityManager).creationCode, abi.encode(factory, weth)) // ); - // lendgineRouter = create2.deploy( + // squaredRouter = create2.deploy( // keccak256("SquaredRouter"), // bytes.concat(type(SquaredRouter).creationCode, abi.encode(factory, uniV2Factory, uniV3Factory, weth)) // ); diff --git a/script/SetupLocal.s.sol b/script/SetupLocal.s.sol index 5afc2c7..2e7cf44 100644 --- a/script/SetupLocal.s.sol +++ b/script/SetupLocal.s.sol @@ -7,7 +7,7 @@ import { console2 } from "forge-std/console2.sol"; import { Factory } from "../src/core/Factory.sol"; import { LiquidityManager } from "../src/periphery/LiquidityManager.sol"; -import { LendgineRouter } from "../src/periphery/LendgineRouter.sol"; +import { SquaredRouter } from "../src/periphery/SquaredRouter.sol"; import { SwapHelper } from "../src/periphery/SwapHelper.sol"; import { ERC20 } from "../src/core/ERC20.sol"; import { IWETH9 } from "../src/periphery/interfaces/external/IWETH9.sol"; @@ -54,20 +54,20 @@ contract SetupLocalScript is Script { // deploy core contracts vm.startBroadcast(pk); - Factory factory = new Factory{salt: keccak256("NumoFactoryTest1")}(); + Factory factory = new Factory{salt: keccak256("FactoryTest1")}(); LiquidityManager liquidityManager = - new LiquidityManager{salt: keccak256("NumoLiquidityManagerTest1")}(address(factory), weth); - LendgineRouter lendgineRouter = new LendgineRouter{salt: keccak256("NumoLendgineRouterTest1")}( + new LiquidityManager{salt: keccak256("SquaredLiquidityManagerTest1")}(address(factory), weth); + SquaredRouter squaredRouter = new SquaredRouter{salt: keccak256("SquaredRouterTest1")}( address(factory), uniV2Factory, uniV3Factory, weth ); - // deploy new lendgines - console2.log("usdc/weth lendgine: ", factory.createLendgine(usdc, weth, 6, 18, usdcWethBound)); - console2.log("weth/uni lendgine: ", factory.createLendgine(weth, uni, 18, 18, wethUniBound)); - console2.log("uni/weth lendgine: ", factory.createLendgine(uni, weth, 18, 18, uniWethBound)); + // deploy new squareds + console2.log("usdc/weth squared: ", factory.createSquared(usdc, weth, 6, 18, usdcWethBound)); + console2.log("weth/uni squared: ", factory.createSquared(weth, uni, 18, 18, wethUniBound)); + console2.log("uni/weth squared: ", factory.createSquared(uni, weth, 18, 18, uniWethBound)); // mint tokens to addr IWETH9(weth).deposit{ value: 100 ether }(); @@ -130,10 +130,10 @@ contract SetupLocalScript is Script { ); // borrow from market - ERC20(uni).approve(address(lendgineRouter), 50 * 1e18); + ERC20(uni).approve(address(squaredRouter), 50 * 1e18); - lendgineRouter.mint( - LendgineRouter.MintParams({ + squaredRouter.mint( + SquaredRouter.MintParams({ token0: weth, token1: uni, token0Exp: 18, diff --git a/src/core/Factory.sol b/src/core/Factory.sol index 177eae5..106feba 100644 --- a/src/core/Factory.sol +++ b/src/core/Factory.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only pragma solidity ^0.8.4; -import { Lendgine } from "./Lendgine.sol"; +import { Squared } from "./Squared.sol"; import { IFactory } from "./interfaces/IFactory.sol"; @@ -10,13 +10,13 @@ contract Factory is IFactory { EVENTS //////////////////////////////////////////////////////////////*/ - event LendgineCreated( + event SquaredCreated( address indexed token0, address indexed token1, uint256 token0Exp, uint256 token1Exp, uint256 indexed upperBound, - address lendgine + address squared ); /*////////////////////////////////////////////////////////////// @@ -38,7 +38,7 @@ contract Factory is IFactory { /// @inheritdoc IFactory mapping(address => mapping(address => mapping(uint256 => mapping(uint256 => mapping(uint256 => address))))) public - override getLendgine; + override getSquared; /*////////////////////////////////////////////////////////////// TEMPORARY DEPLOY STORAGE @@ -60,7 +60,7 @@ contract Factory is IFactory { //////////////////////////////////////////////////////////////*/ /// @inheritdoc IFactory - function createLendgine( + function createSquared( address token0, address token1, uint8 token0Exp, @@ -69,21 +69,21 @@ contract Factory is IFactory { ) external override - returns (address lendgine) + returns (address squared) { if (token0 == token1) revert SameTokenError(); if (token0 == address(0) || token1 == address(0)) revert ZeroAddressError(); - if (getLendgine[token0][token1][token0Exp][token1Exp][upperBound] != address(0)) revert DeployedError(); + if (getSquared[token0][token1][token0Exp][token1Exp][upperBound] != address(0)) revert DeployedError(); if (token0Exp > 18 || token0Exp < 6 || token1Exp > 18 || token1Exp < 6) revert ScaleError(); parameters = Parameters({ token0: token0, token1: token1, token0Exp: token0Exp, token1Exp: token1Exp, upperBound: upperBound }); - lendgine = address(new Lendgine{ salt: keccak256(abi.encode(token0, token1, token0Exp, token1Exp, upperBound)) }()); + squared = address(new Squared{ salt: keccak256(abi.encode(token0, token1, token0Exp, token1Exp, upperBound)) }()); delete parameters; - getLendgine[token0][token1][token0Exp][token1Exp][upperBound] = lendgine; - emit LendgineCreated(token0, token1, token0Exp, token1Exp, upperBound, lendgine); + getSquared[token0][token1][token0Exp][token1Exp][upperBound] = squared; + emit SquaredCreated(token0, token1, token0Exp, token1Exp, upperBound, squared); } } diff --git a/src/core/Lendgine.sol b/src/core/Squared.sol similarity index 93% rename from src/core/Lendgine.sol rename to src/core/Squared.sol index 01e94dd..c3feeae 100644 --- a/src/core/Lendgine.sol +++ b/src/core/Squared.sol @@ -5,7 +5,7 @@ import { ERC20 } from "./ERC20.sol"; import { JumpRate } from "./JumpRate.sol"; import { Pair } from "./Pair.sol"; -import { ILendgine } from "./interfaces/ILendgine.sol"; +import { ISquared } from "./interfaces/ISquared.sol"; import { IMintCallback } from "./interfaces/callback/IMintCallback.sol"; import { Balance } from "../libraries/Balance.sol"; @@ -14,7 +14,7 @@ import { Position } from "./libraries/Position.sol"; import { SafeTransferLib } from "../libraries/SafeTransferLib.sol"; import { SafeCast } from "../libraries/SafeCast.sol"; -contract Lendgine is ERC20, JumpRate, Pair, ILendgine { +contract Squared is ERC20, JumpRate, Pair, ISquared { using Position for mapping(address => Position.Info); using Position for Position.Info; @@ -49,25 +49,25 @@ contract Lendgine is ERC20, JumpRate, Pair, ILendgine { error InsufficientPositionError(); /*////////////////////////////////////////////////////////////// - LENDGINE STORAGE + Squared STORAGE //////////////////////////////////////////////////////////////*/ - /// @inheritdoc ILendgine + /// @inheritdoc ISquared mapping(address => Position.Info) public override positions; - /// @inheritdoc ILendgine + /// @inheritdoc ISquared uint256 public override totalPositionSize; - /// @inheritdoc ILendgine + /// @inheritdoc ISquared uint256 public override totalLiquidityBorrowed; - /// @inheritdoc ILendgine + /// @inheritdoc ISquared uint256 public override rewardPerPositionStored; - /// @inheritdoc ILendgine + /// @inheritdoc ISquared uint256 public override lastUpdate; - /// @inheritdoc ILendgine + /// @inheritdoc ISquared function mint( address to, uint256 collateral, @@ -101,7 +101,7 @@ contract Lendgine is ERC20, JumpRate, Pair, ILendgine { emit Mint(msg.sender, collateral, shares, liquidity, to); } - /// @inheritdoc ILendgine + /// @inheritdoc ISquared function burn(address to, bytes calldata data) external override nonReentrant returns (uint256 collateral) { _accrueInterest(); @@ -119,7 +119,7 @@ contract Lendgine is ERC20, JumpRate, Pair, ILendgine { emit Burn(msg.sender, collateral, shares, liquidity, to); } - /// @inheritdoc ILendgine + /// @inheritdoc ISquared function deposit( address to, uint256 liquidity, @@ -148,7 +148,7 @@ contract Lendgine is ERC20, JumpRate, Pair, ILendgine { emit Deposit(msg.sender, size, liquidity, to); } - /// @inheritdoc ILendgine + /// @inheritdoc ISquared function withdraw( address to, uint256 size @@ -179,18 +179,18 @@ contract Lendgine is ERC20, JumpRate, Pair, ILendgine { emit Withdraw(msg.sender, size, liquidity, to); } - /// @inheritdoc ILendgine + /// @inheritdoc ISquared function accrueInterest() external override nonReentrant { _accrueInterest(); } - /// @inheritdoc ILendgine + /// @inheritdoc ISquared function accruePositionInterest() external override nonReentrant { _accrueInterest(); _accruePositionInterest(msg.sender); } - /// @inheritdoc ILendgine + /// @inheritdoc ISquared function collect(address to, uint256 collateralRequested) external override nonReentrant returns (uint256 collateral) { Position.Info storage position = positions[msg.sender]; // SLOAD uint256 tokensOwed = position.tokensOwed; @@ -209,23 +209,23 @@ contract Lendgine is ERC20, JumpRate, Pair, ILendgine { ACCOUNTING LOGIC //////////////////////////////////////////////////////////////*/ - /// @inheritdoc ILendgine + /// @inheritdoc ISquared function convertLiquidityToShare(uint256 liquidity) public view override returns (uint256) { uint256 _totalLiquidityBorrowed = totalLiquidityBorrowed; // SLOAD return _totalLiquidityBorrowed == 0 ? liquidity : FullMath.mulDiv(liquidity, totalSupply, _totalLiquidityBorrowed); } - /// @inheritdoc ILendgine + /// @inheritdoc ISquared function convertShareToLiquidity(uint256 shares) public view override returns (uint256) { return FullMath.mulDiv(totalLiquidityBorrowed, shares, totalSupply); } - /// @inheritdoc ILendgine + /// @inheritdoc ISquared function convertCollateralToLiquidity(uint256 collateral) public view override returns (uint256) { return FullMath.mulDiv(collateral * token1Scale, 1e18, 2 * upperBound); } - /// @inheritdoc ILendgine + /// @inheritdoc ISquared function convertLiquidityToCollateral(uint256 liquidity) public view override returns (uint256) { return FullMath.mulDiv(liquidity, 2 * upperBound, 1e18) / token1Scale; } @@ -234,7 +234,7 @@ contract Lendgine is ERC20, JumpRate, Pair, ILendgine { INTERNAL INTEREST LOGIC //////////////////////////////////////////////////////////////*/ - /// @notice Helper function for accruing lendgine interest + /// @notice Helper function for accruing Squared interest function _accrueInterest() private { if (totalSupply == 0 || totalLiquidityBorrowed == 0) { lastUpdate = block.timestamp; diff --git a/src/core/interfaces/IFactory.sol b/src/core/interfaces/IFactory.sol index 36f05da..551951d 100644 --- a/src/core/interfaces/IFactory.sol +++ b/src/core/interfaces/IFactory.sol @@ -1,14 +1,14 @@ // SPDX-License-Identifier: GPL-3.0-only pragma solidity >=0.5.0; -/// @notice Manages the recording and creation of Numo markets +/// @notice Manages the recording and creation of Squared positions /// @author Kyle Scott and Robert Leifke /// @author Modified from Uniswap (https://github.com/Uniswap/v2-core/blob/master/contracts/UniswapV2Factory.sol) /// and Primitive (https://github.com/primitivefinance/rmm-core/blob/main/contracts/PrimitiveFactory.sol) interface IFactory { - /// @notice Returns the lendgine address for a given pair of tokens and upper bound + /// @notice Returns the Squared address for a given pair of tokens and upper bound /// @dev returns address 0 if it doesn't exist - function getLendgine( + function getSquared( address token0, address token1, uint256 token0Exp, @@ -17,19 +17,19 @@ interface IFactory { ) external view - returns (address lendgine); + returns (address squared); - /// @notice Get the parameters to be used in constructing the lendgine, set - /// transiently during lendgine creation - /// @dev Called by the immutable state constructor to fetch the parameters of the lendgine + /// @notice Get the parameters to be used in constructing the Squared, set + /// transiently during Squared position creation + /// @dev Called by the immutable state constructor to fetch the parameters of the Squared function parameters() external view returns (address token0, address token1, uint128 token0Exp, uint128 token1Exp, uint256 upperBound); - /// @notice Deploys a lendgine contract by transiently setting the parameters storage slots - /// and clearing it after the lendgine has been deployed - function createLendgine( + /// @notice Deploys a squared contract by transiently setting the parameters storage slots + /// and clearing it after the squared has been deployed + function createSquared( address token0, address token1, uint8 token0Exp, diff --git a/src/core/interfaces/IImmutableState.sol b/src/core/interfaces/IImmutableState.sol index 8694261..62347f0 100644 --- a/src/core/interfaces/IImmutableState.sol +++ b/src/core/interfaces/IImmutableState.sol @@ -4,7 +4,7 @@ pragma solidity >=0.5.0; /// @notice Immutable state interface /// @author Kyle Scott and Robert Leifke interface IImmutableState { - /// @notice The contract that deployed the lendgine + /// @notice The contract that deployed the squared function factory() external view returns (address); /// @notice The "numeraire" or "base" token in the pair diff --git a/src/core/interfaces/ILendgine.sol b/src/core/interfaces/ISquared.sol similarity index 99% rename from src/core/interfaces/ILendgine.sol rename to src/core/interfaces/ISquared.sol index 67236a3..9dfc701 100644 --- a/src/core/interfaces/ILendgine.sol +++ b/src/core/interfaces/ISquared.sol @@ -5,7 +5,7 @@ import { IPair } from "./IPair.sol"; /// @notice Lending engine for borrowing and lending liquidity provider shares /// @author Kyle Scott and Robert Leifke -interface ILendgine is IPair { +interface ISquared is IPair { /// @notice Returns information about a position given the controllers address function positions(address) external view returns (uint256, uint256, uint256); diff --git a/src/core/interfaces/callback/IMintCallback.sol b/src/core/interfaces/callback/IMintCallback.sol index ee2fb06..706ddb6 100644 --- a/src/core/interfaces/callback/IMintCallback.sol +++ b/src/core/interfaces/callback/IMintCallback.sol @@ -2,9 +2,9 @@ pragma solidity >=0.5.0; interface IMintCallback { - /// @notice Called to `msg.sender` after executing a mint via Lendgine + /// @notice Called to `msg.sender` after executing a mint via squared /// @dev In the implementation you must pay the speculative tokens owed for the mint. - /// The caller of this method must be checked to be a Lendgine deployed by the canonical Factory. + /// The caller of this method must be checked to be a squared deployed by the canonical Factory. /// @param data Any data passed through by the caller via the Mint call function mintCallback( uint256 collateral, diff --git a/src/core/libraries/Position.sol b/src/core/libraries/Position.sol index 6ab3d07..c434d73 100644 --- a/src/core/libraries/Position.sol +++ b/src/core/libraries/Position.sol @@ -4,7 +4,7 @@ pragma solidity ^0.8.4; import { PositionMath } from "./PositionMath.sol"; import { FullMath } from "../../libraries/FullMath.sol"; -/// @notice Library for handling Lendgine liquidity positions +/// @notice Library for handling squared liquidity positions /// @author Kyle Scott and Leifke /// @author Modified from Uniswap (https://github.com/Uniswap/v3-core/blob/main/contracts/libraries/Position.sol) library Position { diff --git a/src/periphery/LiquidityManager.sol b/src/periphery/LiquidityManager.sol index d1524ef..07169cd 100644 --- a/src/periphery/LiquidityManager.sol +++ b/src/periphery/LiquidityManager.sol @@ -5,11 +5,11 @@ import { Multicall } from "./Multicall.sol"; import { Payment } from "./Payment.sol"; import { SelfPermit } from "./SelfPermit.sol"; -import { ILendgine } from "../core/interfaces/ILendgine.sol"; +import { ISquared } from "../core/interfaces/ISquared.sol"; import { IPairMintCallback } from "../core/interfaces/callback/IPairMintCallback.sol"; import { FullMath } from "../libraries/FullMath.sol"; -import { LendgineAddress } from "./libraries/LendgineAddress.sol"; +import { SquaredAddress } from "./libraries/SquaredAddress.sol"; /// @notice Manages liquidity provider positions /// @author Kyle Scott and Robert Leifke @@ -19,7 +19,7 @@ contract LiquidityManager is Multicall, Payment, SelfPermit, IPairMintCallback { //////////////////////////////////////////////////////////////*/ event AddLiquidity( address indexed from, - address indexed lendgine, + address indexed squared, uint256 liquidity, uint256 size, uint256 amount0, @@ -29,7 +29,7 @@ contract LiquidityManager is Multicall, Payment, SelfPermit, IPairMintCallback { event RemoveLiquidity( address indexed from, - address indexed lendgine, + address indexed squared, uint256 liquidity, uint256 size, uint256 amount0, @@ -37,7 +37,7 @@ contract LiquidityManager is Multicall, Payment, SelfPermit, IPairMintCallback { address indexed to ); - event Collect(address indexed from, address indexed lendgine, uint256 amount, address indexed to); + event Collect(address indexed from, address indexed squared, uint256 amount, address indexed to); /*////////////////////////////////////////////////////////////// ERRORS @@ -65,7 +65,7 @@ contract LiquidityManager is Multicall, Payment, SelfPermit, IPairMintCallback { uint256 tokensOwed; } - /// @notice Owner to lendgine to position + /// @notice Owner to squared to position mapping(address => mapping(address => Position)) public positions; /*////////////////////////////////////////////////////////////// @@ -104,10 +104,10 @@ contract LiquidityManager is Multicall, Payment, SelfPermit, IPairMintCallback { function pairMintCallback(uint256, bytes calldata data) external { PairMintCallbackData memory decoded = abi.decode(data, (PairMintCallbackData)); - address lendgine = LendgineAddress.computeAddress( + address squared = SquaredAddress.computeAddress( factory, decoded.token0, decoded.token1, decoded.token0Exp, decoded.token1Exp, decoded.upperBound ); - if (lendgine != msg.sender) revert ValidationError(); + if (squared != msg.sender) revert ValidationError(); if (decoded.amount0 > 0) pay(decoded.token0, decoded.payer, msg.sender, decoded.amount0); if (decoded.amount1 > 0) pay(decoded.token1, decoded.payer, msg.sender, decoded.amount1); @@ -133,13 +133,13 @@ contract LiquidityManager is Multicall, Payment, SelfPermit, IPairMintCallback { /// @notice Add liquidity to a liquidity position function addLiquidity(AddLiquidityParams calldata params) external payable checkDeadline(params.deadline) { - address lendgine = LendgineAddress.computeAddress( + address squared = SquaredAddress.computeAddress( factory, params.token0, params.token1, params.token0Exp, params.token1Exp, params.upperBound ); - uint256 r0 = ILendgine(lendgine).reserve0(); - uint256 r1 = ILendgine(lendgine).reserve1(); - uint256 totalLiquidity = ILendgine(lendgine).totalLiquidity(); + uint256 r0 = ISquared(squared).reserve0(); + uint256 r1 = ISquared(squared).reserve1(); + uint256 totalLiquidity = ISquared(squared).totalLiquidity(); uint256 amount0; uint256 amount1; @@ -154,7 +154,7 @@ contract LiquidityManager is Multicall, Payment, SelfPermit, IPairMintCallback { if (amount0 < params.amount0Min || amount1 < params.amount1Min) revert AmountError(); - uint256 size = ILendgine(lendgine).deposit( + uint256 size = ISquared(squared).deposit( address(this), params.liquidity, abi.encode( @@ -172,16 +172,16 @@ contract LiquidityManager is Multicall, Payment, SelfPermit, IPairMintCallback { ); if (size < params.sizeMin) revert AmountError(); - Position memory position = positions[params.recipient][lendgine]; // SLOAD + Position memory position = positions[params.recipient][squared]; // SLOAD - (, uint256 rewardPerPositionPaid,) = ILendgine(lendgine).positions(address(this)); + (, uint256 rewardPerPositionPaid,) = ISquared(squared).positions(address(this)); position.tokensOwed += FullMath.mulDiv(position.size, rewardPerPositionPaid - position.rewardPerPositionPaid, 1e18); position.rewardPerPositionPaid = rewardPerPositionPaid; position.size += size; - positions[params.recipient][lendgine] = position; // SSTORE + positions[params.recipient][squared] = position; // SSTORE - emit AddLiquidity(msg.sender, lendgine, params.liquidity, size, amount0, amount1, params.recipient); + emit AddLiquidity(msg.sender, squared, params.liquidity, size, amount0, amount1, params.recipient); } struct RemoveLiquidityParams { @@ -199,53 +199,53 @@ contract LiquidityManager is Multicall, Payment, SelfPermit, IPairMintCallback { /// @notice Removes from a liquidity position function removeLiquidity(RemoveLiquidityParams calldata params) external payable checkDeadline(params.deadline) { - address lendgine = LendgineAddress.computeAddress( + address squared = SquaredAddress.computeAddress( factory, params.token0, params.token1, params.token0Exp, params.token1Exp, params.upperBound ); address recipient = params.recipient == address(0) ? address(this) : params.recipient; - (uint256 amount0, uint256 amount1, uint256 liquidity) = ILendgine(lendgine).withdraw(recipient, params.size); + (uint256 amount0, uint256 amount1, uint256 liquidity) = ISquared(squared).withdraw(recipient, params.size); if (amount0 < params.amount0Min || amount1 < params.amount1Min) revert AmountError(); - Position memory position = positions[msg.sender][lendgine]; // SLOAD + Position memory position = positions[msg.sender][squared]; // SLOAD - (, uint256 rewardPerPositionPaid,) = ILendgine(lendgine).positions(address(this)); + (, uint256 rewardPerPositionPaid,) = ISquared(squared).positions(address(this)); position.tokensOwed += FullMath.mulDiv(position.size, rewardPerPositionPaid - position.rewardPerPositionPaid, 1e18); position.rewardPerPositionPaid = rewardPerPositionPaid; position.size -= params.size; - positions[msg.sender][lendgine] = position; // SSTORE + positions[msg.sender][squared] = position; // SSTORE - emit RemoveLiquidity(msg.sender, lendgine, liquidity, params.size, amount0, amount1, recipient); + emit RemoveLiquidity(msg.sender, squared, liquidity, params.size, amount0, amount1, recipient); } struct CollectParams { - address lendgine; + address squared; address recipient; uint256 amountRequested; } /// @notice Collects interest owed to the callers liqudity position function collect(CollectParams calldata params) external payable returns (uint256 amount) { - ILendgine(params.lendgine).accruePositionInterest(); + ISquared(params.squared).accruePositionInterest(); address recipient = params.recipient == address(0) ? address(this) : params.recipient; - Position memory position = positions[msg.sender][params.lendgine]; // SLOAD + Position memory position = positions[msg.sender][params.squared]; // SLOAD - (, uint256 rewardPerPositionPaid,) = ILendgine(params.lendgine).positions(address(this)); + (, uint256 rewardPerPositionPaid,) = ISquared(params.squared).positions(address(this)); position.tokensOwed += FullMath.mulDiv(position.size, rewardPerPositionPaid - position.rewardPerPositionPaid, 1e18); position.rewardPerPositionPaid = rewardPerPositionPaid; amount = params.amountRequested > position.tokensOwed ? position.tokensOwed : params.amountRequested; position.tokensOwed -= amount; - positions[msg.sender][params.lendgine] = position; // SSTORE + positions[msg.sender][params.squared] = position; // SSTORE - uint256 collectAmount = ILendgine(params.lendgine).collect(recipient, amount); + uint256 collectAmount = ISquared(params.squared).collect(recipient, amount); if (collectAmount != amount) revert CollectError(); // extra check for safety - emit Collect(msg.sender, params.lendgine, amount, recipient); + emit Collect(msg.sender, params.squared, amount, recipient); } } diff --git a/src/periphery/LendgineRouter.sol b/src/periphery/SquaredRouter.sol similarity index 83% rename from src/periphery/LendgineRouter.sol rename to src/periphery/SquaredRouter.sol index 1f74bcd..56ba407 100644 --- a/src/periphery/LendgineRouter.sol +++ b/src/periphery/SquaredRouter.sol @@ -6,25 +6,25 @@ import { Payment } from "./Payment.sol"; import { SelfPermit } from "./SelfPermit.sol"; import { SwapHelper } from "./SwapHelper.sol"; -import { ILendgine } from "../core/interfaces/ILendgine.sol"; +import { ISquared } from "../core/interfaces/ISquared.sol"; import { IMintCallback } from "../core/interfaces/callback/IMintCallback.sol"; import { IPairMintCallback } from "../core/interfaces/callback/IPairMintCallback.sol"; import { FullMath } from "../libraries/FullMath.sol"; -import { LendgineAddress } from "./libraries/LendgineAddress.sol"; +import { SquaredAddress } from "./libraries/SquaredAddress.sol"; import { SafeCast } from "../libraries/SafeCast.sol"; import { SafeTransferLib } from "../libraries/SafeTransferLib.sol"; -/// @notice Contract for automatically entering and exiting option positions +/// @notice Contract for automatically entering and exiting Squared positions /// @author Kyle Scott and Robert Leifke -contract LendgineRouter is Multicall, Payment, SelfPermit, SwapHelper, IMintCallback, IPairMintCallback { +contract SquaredRouter is Multicall, Payment, SelfPermit, SwapHelper, IMintCallback, IPairMintCallback { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ - event Mint(address indexed from, address indexed lendgine, uint256 collateral, uint256 shares, address indexed to); + event Mint(address indexed from, address indexed squared, uint256 collateral, uint256 shares, address indexed to); - event Burn(address indexed from, address indexed lendgine, uint256 collateral, uint256 shares, address indexed to); + event Burn(address indexed from, address indexed squared, uint256 collateral, uint256 shares, address indexed to); /*////////////////////////////////////////////////////////////// ERRORS @@ -96,10 +96,10 @@ contract LendgineRouter is Multicall, Payment, SelfPermit, SwapHelper, IMintCall { MintCallbackData memory decoded = abi.decode(data, (MintCallbackData)); - address lendgine = LendgineAddress.computeAddress( + address squared = SquaredAddress.computeAddress( factory, decoded.token0, decoded.token1, decoded.token0Exp, decoded.token1Exp, decoded.upperBound ); - if (lendgine != msg.sender) revert ValidationError(); + if (squared != msg.sender) revert ValidationError(); // swap all token0 to token1 uint256 collateralSwap = swap( @@ -140,11 +140,11 @@ contract LendgineRouter is Multicall, Payment, SelfPermit, SwapHelper, IMintCall /// @notice Use token1 to completely mint an option position function mint(MintParams calldata params) external payable checkDeadline(params.deadline) returns (uint256 shares) { - address lendgine = LendgineAddress.computeAddress( + address squared = SquaredAddress.computeAddress( factory, params.token0, params.token1, params.token0Exp, params.token1Exp, params.upperBound ); - shares = ILendgine(lendgine).mint( + shares = ISquared(squared).mint( address(this), params.amountIn + params.amountBorrow, abi.encode( @@ -163,9 +163,9 @@ contract LendgineRouter is Multicall, Payment, SelfPermit, SwapHelper, IMintCall ); if (shares < params.sharesMin) revert AmountError(); - SafeTransferLib.safeTransfer(lendgine, params.recipient, shares); + SafeTransferLib.safeTransfer(squared, params.recipient, shares); - emit Mint(msg.sender, lendgine, params.amountIn, shares, params.recipient); + emit Mint(msg.sender, squared, params.amountIn, shares, params.recipient); } /*////////////////////////////////////////////////////////////// @@ -190,14 +190,14 @@ contract LendgineRouter is Multicall, Payment, SelfPermit, SwapHelper, IMintCall function pairMintCallback(uint256 liquidity, bytes calldata data) external override { PairMintCallbackData memory decoded = abi.decode(data, (PairMintCallbackData)); - address lendgine = LendgineAddress.computeAddress( + address squared = SquaredAddress.computeAddress( factory, decoded.token0, decoded.token1, decoded.token0Exp, decoded.token1Exp, decoded.upperBound ); - if (lendgine != msg.sender) revert ValidationError(); + if (squared != msg.sender) revert ValidationError(); - uint256 r0 = ILendgine(msg.sender).reserve0(); - uint256 r1 = ILendgine(msg.sender).reserve1(); - uint256 totalLiquidity = ILendgine(msg.sender).totalLiquidity(); + uint256 r0 = ISquared(msg.sender).reserve0(); + uint256 r1 = ISquared(msg.sender).reserve1(); + uint256 totalLiquidity = ISquared(msg.sender).totalLiquidity(); uint256 amount0; uint256 amount1; @@ -228,7 +228,7 @@ contract LendgineRouter is Multicall, Payment, SelfPermit, SwapHelper, IMintCall SafeTransferLib.safeTransfer(decoded.token1, msg.sender, amount1); // determine remaining and send to recipient - uint256 collateralTotal = ILendgine(msg.sender).convertLiquidityToCollateral(liquidity); + uint256 collateralTotal = ISquared(msg.sender).convertLiquidityToCollateral(liquidity); uint256 collateralOut = collateralTotal - amount1 - collateralSwapped; if (collateralOut < decoded.collateralMin) revert AmountError(); @@ -255,15 +255,15 @@ contract LendgineRouter is Multicall, Payment, SelfPermit, SwapHelper, IMintCall /// @notice Take an option position and withdraw it fully into token1 function burn(BurnParams calldata params) external payable checkDeadline(params.deadline) returns (uint256 amount) { - address lendgine = LendgineAddress.computeAddress( + address squared = SquaredAddress.computeAddress( factory, params.token0, params.token1, params.token0Exp, params.token1Exp, params.upperBound ); address recipient = params.recipient == address(0) ? address(this) : params.recipient; - SafeTransferLib.safeTransferFrom(lendgine, msg.sender, lendgine, params.shares); + SafeTransferLib.safeTransferFrom(squared, msg.sender, squared, params.shares); - amount = ILendgine(lendgine).burn( + amount = ISquared(squared).burn( address(this), abi.encode( PairMintCallbackData({ @@ -282,6 +282,6 @@ contract LendgineRouter is Multicall, Payment, SelfPermit, SwapHelper, IMintCall ) ); - emit Burn(msg.sender, lendgine, amount, params.shares, recipient); + emit Burn(msg.sender, squared, amount, params.shares, recipient); } } diff --git a/src/periphery/libraries/LendgineAddress.sol b/src/periphery/libraries/SquaredAddress.sol similarity index 66% rename from src/periphery/libraries/LendgineAddress.sol rename to src/periphery/libraries/SquaredAddress.sol index b3b9d9a..a5cded9 100644 --- a/src/periphery/libraries/LendgineAddress.sol +++ b/src/periphery/libraries/SquaredAddress.sol @@ -1,10 +1,10 @@ // SPDX-License-Identifier: GPL-3.0-only pragma solidity >=0.5.0; -import { Lendgine } from "../../core/Lendgine.sol"; +import { Squared } from "../../core/Squared.sol"; -/// @notice Library for computing the address of a lendgine using only its inputs -library LendgineAddress { +/// @notice Library for computing the address of a Squared using only its inputs +library SquaredAddress { function computeAddress( address factory, @@ -16,9 +16,9 @@ library LendgineAddress { ) internal pure - returns (address lendgine) + returns (address squared) { - lendgine = address( + squared = address( uint160( uint256( keccak256( @@ -26,7 +26,7 @@ library LendgineAddress { hex"ff", factory, keccak256(abi.encode(token0, token1, token0Exp, token1Exp, upperBound)), - keccak256(type(Lendgine).creationCode) + keccak256(type(Squared).creationCode) ) ) ) diff --git a/test/AccrueInterestTest.t.sol b/test/AccrueInterestTest.t.sol index 158ecb9..033f2c5 100644 --- a/test/AccrueInterestTest.t.sol +++ b/test/AccrueInterestTest.t.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only pragma solidity ^0.8.0; -import { Lendgine } from "../src/core/Lendgine.sol"; +import { Squared } from "../src/core/Squared.sol"; import { Pair } from "../src/core/Pair.sol"; import { TestHelper } from "./utils/TestHelper.sol"; @@ -13,22 +13,22 @@ contract AccrueInterestTest is TestHelper { } function testAccrueNoLiquidity() external { - lendgine.accrueInterest(); + squared.accrueInterest(); - assertEq(1, lendgine.lastUpdate()); - assertEq(0, lendgine.rewardPerPositionStored()); - assertEq(0, lendgine.totalLiquidityBorrowed()); + assertEq(1, squared.lastUpdate()); + assertEq(0, squared.rewardPerPositionStored()); + assertEq(0, squared.totalLiquidityBorrowed()); } function testAccrueNoTime() external { _deposit(cuh, cuh, 1 ether, 8 ether, 1 ether); _mint(cuh, cuh, 5 ether); - lendgine.accrueInterest(); + squared.accrueInterest(); - assertEq(1, lendgine.lastUpdate()); - assertEq(0, lendgine.rewardPerPositionStored()); - assertEq(0.5 ether, lendgine.totalLiquidityBorrowed()); + assertEq(1, squared.lastUpdate()); + assertEq(0, squared.rewardPerPositionStored()); + assertEq(0.5 ether, squared.totalLiquidityBorrowed()); } function testAccrueInterest() external { @@ -37,15 +37,15 @@ contract AccrueInterestTest is TestHelper { vm.warp(365 days + 1); - lendgine.accrueInterest(); + squared.accrueInterest(); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year uint256 token1Dilution = 10 * lpDilution; // same as rewardPerPosition because position size is 1 - assertEq(365 days + 1, lendgine.lastUpdate()); - assertEq(0.5 ether - lpDilution, lendgine.totalLiquidityBorrowed()); - assertEq(token1Dilution, lendgine.rewardPerPositionStored()); + assertEq(365 days + 1, squared.lastUpdate()); + assertEq(0.5 ether - lpDilution, squared.totalLiquidityBorrowed()); + assertEq(token1Dilution, squared.rewardPerPositionStored()); } function testMaxDilution() external { @@ -54,37 +54,37 @@ contract AccrueInterestTest is TestHelper { vm.warp(730 days + 1); - lendgine.accrueInterest(); + squared.accrueInterest(); - assertEq(730 days + 1, lendgine.lastUpdate()); - assertEq(0, lendgine.totalLiquidityBorrowed()); - assertEq(5 ether, lendgine.rewardPerPositionStored()); + assertEq(730 days + 1, squared.lastUpdate()); + assertEq(0, squared.totalLiquidityBorrowed()); + assertEq(5 ether, squared.rewardPerPositionStored()); } - function testLendgineEmit() external { + function testsquaredEmit() external { _deposit(cuh, cuh, 1 ether, 8 ether, 1 ether); _mint(cuh, cuh, 5 ether); vm.warp(365 days + 1); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year uint256 token1Dilution = 10 * lpDilution; // same as rewardPerPosition because position size is 1 - vm.expectEmit(false, false, false, true, address(lendgine)); + vm.expectEmit(false, false, false, true, address(squared)); emit AccrueInterest(365 days, token1Dilution, lpDilution); - lendgine.accrueInterest(); + squared.accrueInterest(); } function testNonStandardDecimals() external { token1Scale = 9; - lendgine = Lendgine(factory.createLendgine(address(token0), address(token1), token0Scale, token1Scale, upperBound)); + squared = Squared(factory.createSquared(address(token0), address(token1), token0Scale, token1Scale, upperBound)); token0.mint(address(this), 1e18); token1.mint(address(this), 8 * 1e9); - lendgine.deposit( + squared.deposit( address(this), 1 ether, abi.encode( @@ -102,18 +102,18 @@ contract AccrueInterestTest is TestHelper { vm.prank(cuh); token1.approve(address(this), 5 * 1e9); - lendgine.mint(cuh, 5 * 1e9, abi.encode(MintCallbackData({ token: address(token1), payer: cuh }))); + squared.mint(cuh, 5 * 1e9, abi.encode(MintCallbackData({ token: address(token1), payer: cuh }))); vm.warp(365 days + 1); - lendgine.accrueInterest(); + squared.accrueInterest(); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year - uint256 token1Dilution = lendgine.convertLiquidityToCollateral(lpDilution); // same as rewardPerPosition because + uint256 token1Dilution = squared.convertLiquidityToCollateral(lpDilution); // same as rewardPerPosition because // position size is 1 - assertEq(0.5 ether - lpDilution, lendgine.totalLiquidityBorrowed()); - assertEq(token1Dilution, lendgine.rewardPerPositionStored()); + assertEq(0.5 ether - lpDilution, squared.totalLiquidityBorrowed()); + assertEq(token1Dilution, squared.rewardPerPositionStored()); } } diff --git a/test/AccruePositionInterestTest.t.sol b/test/AccruePositionInterestTest.t.sol index 48ea83e..5304aa4 100644 --- a/test/AccruePositionInterestTest.t.sol +++ b/test/AccruePositionInterestTest.t.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only pragma solidity ^0.8.0; -import { Lendgine } from "../src/core/Lendgine.sol"; +import { Squared } from "../src/core/Squared.sol"; import { Pair } from "../src/core/Pair.sol"; import { Position } from "../src/core/libraries/Position.sol"; import { TestHelper } from "./utils/TestHelper.sol"; @@ -16,7 +16,7 @@ contract AccruePositionInterestTest is TestHelper { function testNoPositionError() external { vm.expectRevert(Position.NoPositionError.selector); vm.prank(cuh); - lendgine.accruePositionInterest(); + squared.accruePositionInterest(); } function testNoTime() external { @@ -24,9 +24,9 @@ contract AccruePositionInterestTest is TestHelper { _mint(cuh, cuh, 5 ether); vm.prank(cuh); - lendgine.accruePositionInterest(); + squared.accruePositionInterest(); - (uint256 positionSize, uint256 rewardPerPositionPaid, uint256 tokensOwed) = lendgine.positions(cuh); + (uint256 positionSize, uint256 rewardPerPositionPaid, uint256 tokensOwed) = squared.positions(cuh); assertEq(1 ether, positionSize); assertEq(0, rewardPerPositionPaid); assertEq(0, tokensOwed); @@ -39,31 +39,31 @@ contract AccruePositionInterestTest is TestHelper { vm.warp(365 days + 1); vm.prank(cuh); - lendgine.accruePositionInterest(); + squared.accruePositionInterest(); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year uint256 token1Dilution = 10 * lpDilution; // same as rewardPerPosition because position size is 1 - (uint256 positionSize, uint256 rewardPerPositionPaid, uint256 tokensOwed) = lendgine.positions(cuh); + (uint256 positionSize, uint256 rewardPerPositionPaid, uint256 tokensOwed) = squared.positions(cuh); assertEq(1 ether, positionSize); assertEq(token1Dilution, rewardPerPositionPaid); assertEq(token1Dilution, tokensOwed); } - function testLendgineEmit() external { + function testsquaredEmit() external { _deposit(cuh, cuh, 1 ether, 8 ether, 1 ether); _mint(cuh, cuh, 5 ether); vm.warp(365 days + 1); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year uint256 token1Dilution = 10 * lpDilution; // same as rewardPerPosition because position size is 1 vm.prank(cuh); - vm.expectEmit(true, false, false, true, address(lendgine)); + vm.expectEmit(true, false, false, true, address(squared)); emit AccruePositionInterest(cuh, token1Dilution); - lendgine.accruePositionInterest(); + squared.accruePositionInterest(); } } diff --git a/test/BurnTest.t.sol b/test/BurnTest.t.sol index a84322e..aa49c6d 100644 --- a/test/BurnTest.t.sol +++ b/test/BurnTest.t.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only pragma solidity ^0.8.0; -import { Lendgine } from "../src/core/Lendgine.sol"; +import { Squared } from "../src/core/Squared.sol"; import { Pair } from "../src/core/Pair.sol"; import { TestHelper } from "./utils/TestHelper.sol"; import { FullMath } from "../src/libraries/FullMath.sol"; @@ -25,19 +25,19 @@ contract BurnTest is TestHelper { assertEq(0.25 ether, token0.balanceOf(cuh)); assertEq(2 ether + 2.5 ether, token1.balanceOf(cuh)); - // check lendgine token - assertEq(0.25 ether, lendgine.totalSupply()); - assertEq(0.25 ether, lendgine.balanceOf(cuh)); + // check squared token + assertEq(0.25 ether, squared.totalSupply()); + assertEq(0.25 ether, squared.balanceOf(cuh)); // check storage slots - assertEq(0.25 ether, lendgine.totalLiquidityBorrowed()); - assertEq(0.75 ether, lendgine.totalLiquidity()); - assertEq(0.75 ether, uint256(lendgine.reserve0())); - assertEq(6 ether, uint256(lendgine.reserve1())); - - // check lendgine balances - assertEq(0.75 ether, token0.balanceOf(address(lendgine))); - assertEq(2.5 ether + 6 ether, token1.balanceOf(address(lendgine))); + assertEq(0.25 ether, squared.totalLiquidityBorrowed()); + assertEq(0.75 ether, squared.totalLiquidity()); + assertEq(0.75 ether, uint256(squared.reserve0())); + assertEq(6 ether, uint256(squared.reserve1())); + + // check squared balances + assertEq(0.75 ether, token0.balanceOf(address(squared))); + assertEq(2.5 ether + 6 ether, token1.balanceOf(address(squared))); } function testBurnFull() external { @@ -48,29 +48,29 @@ contract BurnTest is TestHelper { assertEq(0 ether, token0.balanceOf(cuh)); assertEq(5 ether, token1.balanceOf(cuh)); - // check lendgine token - assertEq(0 ether, lendgine.totalSupply()); - assertEq(0 ether, lendgine.balanceOf(cuh)); + // check squared token + assertEq(0 ether, squared.totalSupply()); + assertEq(0 ether, squared.balanceOf(cuh)); // check storage slots - assertEq(0 ether, lendgine.totalLiquidityBorrowed()); - assertEq(1 ether, lendgine.totalLiquidity()); - assertEq(1 ether, uint256(lendgine.reserve0())); - assertEq(8 ether, uint256(lendgine.reserve1())); - - // check lendgine balances - assertEq(1 ether, token0.balanceOf(address(lendgine))); - assertEq(8 ether, token1.balanceOf(address(lendgine))); + assertEq(0 ether, squared.totalLiquidityBorrowed()); + assertEq(1 ether, squared.totalLiquidity()); + assertEq(1 ether, uint256(squared.reserve0())); + assertEq(8 ether, uint256(squared.reserve1())); + + // check squared balances + assertEq(1 ether, token0.balanceOf(address(squared))); + assertEq(8 ether, token1.balanceOf(address(squared))); } function testZeroBurn() external { - vm.expectRevert(Lendgine.InputError.selector); - lendgine.burn(cuh, bytes("")); + vm.expectRevert(Squared.InputError.selector); + squared.burn(cuh, bytes("")); } function testUnderPay() external { vm.prank(cuh); - lendgine.transfer(address(lendgine), 0.5 ether); + squared.transfer(address(squared), 0.5 ether); vm.startPrank(cuh); token0.approve(address(this), 0.5 ether); @@ -78,7 +78,7 @@ contract BurnTest is TestHelper { vm.stopPrank(); vm.expectRevert(Pair.InvariantError.selector); - lendgine.burn( + squared.burn( cuh, abi.encode( PairMintCallbackData({ @@ -92,18 +92,18 @@ contract BurnTest is TestHelper { ); } - function testEmitLendgine() external { + function testEmitsquared() external { vm.prank(cuh); - lendgine.transfer(address(lendgine), 0.5 ether); + squared.transfer(address(squared), 0.5 ether); vm.startPrank(cuh); token0.approve(address(this), 0.5 ether); token1.approve(address(this), 4 ether); vm.stopPrank(); - vm.expectEmit(true, true, false, true, address(lendgine)); + vm.expectEmit(true, true, false, true, address(squared)); emit Burn(address(this), 5 ether, 0.5 ether, 0.5 ether, cuh); - lendgine.burn( + squared.burn( cuh, abi.encode( PairMintCallbackData({ @@ -119,16 +119,16 @@ contract BurnTest is TestHelper { function testEmitPair() external { vm.prank(cuh); - lendgine.transfer(address(lendgine), 0.5 ether); + squared.transfer(address(squared), 0.5 ether); vm.startPrank(cuh); token0.approve(address(this), 0.5 ether); token1.approve(address(this), 4 ether); vm.stopPrank(); - vm.expectEmit(false, false, false, true, address(lendgine)); + vm.expectEmit(false, false, false, true, address(squared)); emit Mint(0.5 ether, 4 ether, 0.5 ether); - lendgine.burn( + squared.burn( cuh, abi.encode( PairMintCallbackData({ @@ -144,57 +144,57 @@ contract BurnTest is TestHelper { function testAccrueOnBurn() external { vm.warp(365 days + 1); - lendgine.accrueInterest(); + squared.accrueInterest(); - uint256 reserve0 = lendgine.reserve0(); - uint256 reserve1 = lendgine.reserve1(); + uint256 reserve0 = squared.reserve0(); + uint256 reserve1 = squared.reserve1(); uint256 amount0 = - FullMath.mulDivRoundingUp(reserve0, lendgine.convertShareToLiquidity(0.5 ether), lendgine.totalLiquidity()); + FullMath.mulDivRoundingUp(reserve0, squared.convertShareToLiquidity(0.5 ether), squared.totalLiquidity()); uint256 amount1 = - FullMath.mulDivRoundingUp(reserve1, lendgine.convertShareToLiquidity(0.5 ether), lendgine.totalLiquidity()); + FullMath.mulDivRoundingUp(reserve1, squared.convertShareToLiquidity(0.5 ether), squared.totalLiquidity()); _burn(cuh, cuh, 0.5 ether, amount0, amount1); - assertEq(365 days + 1, lendgine.lastUpdate()); - assert(lendgine.rewardPerPositionStored() != 0); + assertEq(365 days + 1, squared.lastUpdate()); + assert(squared.rewardPerPositionStored() != 0); } function testProportionalBurn() external { vm.warp(365 days + 1); - lendgine.accrueInterest(); + squared.accrueInterest(); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year - uint256 reserve0 = lendgine.reserve0(); - uint256 reserve1 = lendgine.reserve1(); + uint256 reserve0 = squared.reserve0(); + uint256 reserve1 = squared.reserve1(); uint256 shares = 0.25 ether; uint256 amount0 = - FullMath.mulDivRoundingUp(reserve0, lendgine.convertShareToLiquidity(shares), lendgine.totalLiquidity()); + FullMath.mulDivRoundingUp(reserve0, squared.convertShareToLiquidity(shares), squared.totalLiquidity()); uint256 amount1 = - FullMath.mulDivRoundingUp(reserve1, lendgine.convertShareToLiquidity(shares), lendgine.totalLiquidity()); + FullMath.mulDivRoundingUp(reserve1, squared.convertShareToLiquidity(shares), squared.totalLiquidity()); uint256 collateral = _burn(cuh, cuh, shares, amount0, amount1); // check collateral returned assertEq(5 * (0.5 ether - lpDilution), collateral); // withdrew half the collateral - // check lendgine storage slots - assertEq((0.5 ether - lpDilution) / 2, lendgine.totalLiquidityBorrowed()); // withdrew half the liquidity - assertEq(0.5 ether + (0.5 ether - lpDilution) / 2, lendgine.totalLiquidity()); + // check squared storage slots + assertEq((0.5 ether - lpDilution) / 2, squared.totalLiquidityBorrowed()); // withdrew half the liquidity + assertEq(0.5 ether + (0.5 ether - lpDilution) / 2, squared.totalLiquidity()); } function testNonStandardDecimals() external { token1Scale = 9; - lendgine = Lendgine(factory.createLendgine(address(token0), address(token1), token0Scale, token1Scale, upperBound)); + squared = Squared(factory.createSquared(address(token0), address(token1), token0Scale, token1Scale, upperBound)); token0.mint(address(this), 1e18); token1.mint(address(this), 8 * 1e9); - lendgine.deposit( + squared.deposit( address(this), 1 ether, abi.encode( @@ -210,13 +210,13 @@ contract BurnTest is TestHelper { token1.mint(address(this), 5 * 1e9); - lendgine.mint( + squared.mint( address(this), 5 * 1e9, abi.encode(MintCallbackData({ token: address(token1), payer: address(this) })) ); - lendgine.transfer(address(lendgine), 0.25 ether); + squared.transfer(address(squared), 0.25 ether); - uint256 collateral = lendgine.burn( + uint256 collateral = squared.burn( address(this), abi.encode( PairMintCallbackData({ @@ -234,18 +234,18 @@ contract BurnTest is TestHelper { assertEq(0.25 ether, token0.balanceOf(address(this))); assertEq(4.5 * 1e9, token1.balanceOf(address(this))); - // check lendgine token - assertEq(0.25 ether, lendgine.totalSupply()); - assertEq(0.25 ether, lendgine.balanceOf(address(this))); + // check squared token + assertEq(0.25 ether, squared.totalSupply()); + assertEq(0.25 ether, squared.balanceOf(address(this))); // check storage slots - assertEq(0.25 ether, lendgine.totalLiquidityBorrowed()); - assertEq(0.75 ether, lendgine.totalLiquidity()); - assertEq(0.75 ether, uint256(lendgine.reserve0())); - assertEq(6 * 1e9, uint256(lendgine.reserve1())); - - // check lendgine balances - assertEq(0.75 ether, token0.balanceOf(address(lendgine))); - assertEq(8.5 * 1e9, token1.balanceOf(address(lendgine))); + assertEq(0.25 ether, squared.totalLiquidityBorrowed()); + assertEq(0.75 ether, squared.totalLiquidity()); + assertEq(0.75 ether, uint256(squared.reserve0())); + assertEq(6 * 1e9, uint256(squared.reserve1())); + + // check squared balances + assertEq(0.75 ether, token0.balanceOf(address(squared))); + assertEq(8.5 * 1e9, token1.balanceOf(address(squared))); } } diff --git a/test/CollectTest.t.sol b/test/CollectTest.t.sol index 75c8c3e..82d6d54 100644 --- a/test/CollectTest.t.sol +++ b/test/CollectTest.t.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only pragma solidity ^0.8.0; -import { Lendgine } from "../src/core/Lendgine.sol"; +import { Squared } from "../src/core/Squared.sol"; import { Pair } from "../src/core/Pair.sol"; import { TestHelper } from "./utils/TestHelper.sol"; @@ -13,10 +13,10 @@ contract CollectTest is TestHelper { } function testZeroCollect() external { - uint256 collateral = lendgine.collect(cuh, 0); + uint256 collateral = squared.collect(cuh, 0); assertEq(0, collateral); - collateral = lendgine.collect(cuh, 1 ether); + collateral = squared.collect(cuh, 1 ether); assertEq(0, collateral); } @@ -26,20 +26,20 @@ contract CollectTest is TestHelper { vm.warp(365 days + 1); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year vm.prank(cuh); - lendgine.accruePositionInterest(); + squared.accruePositionInterest(); vm.prank(cuh); - uint256 collateral = lendgine.collect(cuh, lpDilution * 5); + uint256 collateral = squared.collect(cuh, lpDilution * 5); // check return data assertEq(lpDilution * 5, collateral); // check position - (,, uint256 tokensOwed) = lendgine.positions(cuh); + (,, uint256 tokensOwed) = squared.positions(cuh); assertEq(lpDilution * 5, tokensOwed); // check token balances @@ -52,20 +52,20 @@ contract CollectTest is TestHelper { vm.warp(365 days + 1); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year vm.prank(cuh); - lendgine.accruePositionInterest(); + squared.accruePositionInterest(); vm.prank(cuh); - uint256 collateral = lendgine.collect(cuh, 100 ether); + uint256 collateral = squared.collect(cuh, 100 ether); // check return data assertEq(lpDilution * 10, collateral); // check position - (,, uint256 tokensOwed) = lendgine.positions(cuh); + (,, uint256 tokensOwed) = squared.positions(cuh); assertEq(0, tokensOwed); // check token balances @@ -78,15 +78,15 @@ contract CollectTest is TestHelper { vm.warp(365 days + 1); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year vm.prank(cuh); - lendgine.accruePositionInterest(); + squared.accruePositionInterest(); vm.prank(cuh); - vm.expectEmit(true, true, false, true, address(lendgine)); + vm.expectEmit(true, true, false, true, address(squared)); emit Collect(cuh, cuh, lpDilution * 10); - lendgine.collect(cuh, lpDilution * 10); + squared.collect(cuh, lpDilution * 10); } } diff --git a/test/DepositTest.t.sol b/test/DepositTest.t.sol index 153b64a..3fe28ae 100644 --- a/test/DepositTest.t.sol +++ b/test/DepositTest.t.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only pragma solidity ^0.8.0; -import { Lendgine } from "../src/core/Lendgine.sol"; +import { Squared } from "../src/core/Squared.sol"; import { Pair } from "../src/core/Pair.sol"; import { TestHelper } from "./utils/TestHelper.sol"; @@ -17,44 +17,44 @@ contract DepositTest is TestHelper { function testBasicDeposit() external { uint256 size = _deposit(cuh, cuh, 1 ether, 8 ether, 1 ether); - // check lendgine storage slots - assertEq(1 ether, lendgine.totalLiquidity()); - assertEq(1 ether, lendgine.totalPositionSize()); - assertEq(1 ether, uint256(lendgine.reserve0())); - assertEq(8 ether, uint256(lendgine.reserve1())); + // check squared storage slots + assertEq(1 ether, squared.totalLiquidity()); + assertEq(1 ether, squared.totalPositionSize()); + assertEq(1 ether, uint256(squared.reserve0())); + assertEq(8 ether, uint256(squared.reserve1())); - // check lendgine balances - assertEq(1 ether, token0.balanceOf(address(lendgine))); - assertEq(8 ether, token1.balanceOf(address(lendgine))); + // check squared balances + assertEq(1 ether, token0.balanceOf(address(squared))); + assertEq(8 ether, token1.balanceOf(address(squared))); // check position size assertEq(1 ether, size); - (uint256 positionSize,,) = lendgine.positions(cuh); + (uint256 positionSize,,) = squared.positions(cuh); assertEq(1 ether, positionSize); } function testOverDeposit() external { uint256 size = _deposit(cuh, cuh, 1 ether + 1, 8 ether + 1, 1 ether); - // check lendgine storage slots - assertEq(1 ether, lendgine.totalLiquidity()); - assertEq(1 ether, lendgine.totalPositionSize()); - assertEq(1 ether + 1, uint256(lendgine.reserve0())); - assertEq(8 ether + 1, uint256(lendgine.reserve1())); + // check squared storage slots + assertEq(1 ether, squared.totalLiquidity()); + assertEq(1 ether, squared.totalPositionSize()); + assertEq(1 ether + 1, uint256(squared.reserve0())); + assertEq(8 ether + 1, uint256(squared.reserve1())); - // check lendgine balances - assertEq(1 ether + 1, token0.balanceOf(address(lendgine))); - assertEq(8 ether + 1, token1.balanceOf(address(lendgine))); + // check squared balances + assertEq(1 ether + 1, token0.balanceOf(address(squared))); + assertEq(8 ether + 1, token1.balanceOf(address(squared))); // check position size assertEq(1 ether, size); - (uint256 positionSize,,) = lendgine.positions(cuh); + (uint256 positionSize,,) = squared.positions(cuh); assertEq(1 ether, positionSize); } function testZeroMint() external { - vm.expectRevert(Lendgine.InputError.selector); - lendgine.deposit(cuh, 0, bytes("")); + vm.expectRevert(Squared.InputError.selector); + squared.deposit(cuh, 0, bytes("")); } function testUnderPayment() external { @@ -67,7 +67,7 @@ contract DepositTest is TestHelper { vm.stopPrank(); vm.expectRevert(Pair.InvariantError.selector); - lendgine.deposit( + squared.deposit( cuh, 1 ether, abi.encode( @@ -82,7 +82,7 @@ contract DepositTest is TestHelper { ); } - function testEmitLendgine() external { + function testEmitSquared() external { token0.mint(cuh, 1 ether); token1.mint(cuh, 8 ether); @@ -91,9 +91,9 @@ contract DepositTest is TestHelper { token1.approve(address(this), 8 ether); vm.stopPrank(); - vm.expectEmit(true, true, false, true, address(lendgine)); + vm.expectEmit(true, true, false, true, address(squared)); emit Deposit(address(this), 1 ether, 1 ether, cuh); - lendgine.deposit( + squared.deposit( cuh, 1 ether, abi.encode( @@ -117,9 +117,9 @@ contract DepositTest is TestHelper { token1.approve(address(this), 8 ether); vm.stopPrank(); - vm.expectEmit(false, false, false, true, address(lendgine)); + vm.expectEmit(false, false, false, true, address(squared)); emit Mint(1 ether, 8 ether, 1 ether); - lendgine.deposit( + squared.deposit( cuh, 1 ether, abi.encode( @@ -137,7 +137,7 @@ contract DepositTest is TestHelper { function testAccrueOnDepositEmpty() external { _deposit(cuh, cuh, 1 ether, 8 ether, 1 ether); - assertEq(1, lendgine.lastUpdate()); + assertEq(1, squared.lastUpdate()); } function testAccrueOnDeposit() external { @@ -148,8 +148,8 @@ contract DepositTest is TestHelper { _deposit(cuh, cuh, 1 ether, 8 ether, 1 ether); - assertEq(365 days + 1, lendgine.lastUpdate()); - assert(lendgine.rewardPerPositionStored() != 0); + assertEq(365 days + 1, squared.lastUpdate()); + assert(squared.rewardPerPositionStored() != 0); } function testAccrueOnPositionDeposit() external { @@ -160,7 +160,7 @@ contract DepositTest is TestHelper { _deposit(cuh, cuh, 1 ether, 8 ether, 1 ether); - (, uint256 rewardPerPositionPaid, uint256 tokensOwed) = lendgine.positions(cuh); + (, uint256 rewardPerPositionPaid, uint256 tokensOwed) = squared.positions(cuh); assert(rewardPerPositionPaid != 0); assert(tokensOwed != 0); } @@ -173,29 +173,29 @@ contract DepositTest is TestHelper { uint256 size = _deposit(cuh, cuh, 1 ether, 8 ether, 1 ether); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year // check position size assertEq((1 ether * 1 ether) / (1 ether - lpDilution), size); assertApproxEqAbs(1 ether, (size * (2 ether - lpDilution)) / (1 ether + size), 1); - (uint256 positionSize,,) = lendgine.positions(cuh); + (uint256 positionSize,,) = squared.positions(cuh); assertEq((1 ether * 1 ether) / (1 ether - lpDilution), positionSize); - // check lendgine storage slots - assertEq(1 ether + size, lendgine.totalPositionSize()); - assertEq(1.5 ether, lendgine.totalLiquidity()); + // check squared storage slots + assertEq(1 ether + size, squared.totalPositionSize()); + assertEq(1.5 ether, squared.totalLiquidity()); } function testNonStandardDecimals() external { token1Scale = 9; - lendgine = Lendgine(factory.createLendgine(address(token0), address(token1), token0Scale, token1Scale, upperBound)); + squared = Squared(factory.createSquared(address(token0), address(token1), token0Scale, token1Scale, upperBound)); token0.mint(address(this), 1e18); token1.mint(address(this), 8 * 1e9); - uint256 size = lendgine.deposit( + uint256 size = squared.deposit( address(this), 1 ether, abi.encode( @@ -209,19 +209,19 @@ contract DepositTest is TestHelper { ) ); - // check lendgine storage slots - assertEq(1 ether, lendgine.totalLiquidity()); - assertEq(1 ether, lendgine.totalPositionSize()); - assertEq(1 ether, uint256(lendgine.reserve0())); - assertEq(8 * 1e9, uint256(lendgine.reserve1())); + // check squared storage slots + assertEq(1 ether, squared.totalLiquidity()); + assertEq(1 ether, squared.totalPositionSize()); + assertEq(1 ether, uint256(squared.reserve0())); + assertEq(8 * 1e9, uint256(squared.reserve1())); - // check lendgine balances - assertEq(1 ether, token0.balanceOf(address(lendgine))); - assertEq(8 * 1e9, token1.balanceOf(address(lendgine))); + // check squared balances + assertEq(1 ether, token0.balanceOf(address(squared))); + assertEq(8 * 1e9, token1.balanceOf(address(squared))); // check position size assertEq(1 ether, size); - (uint256 positionSize,,) = lendgine.positions(address(this)); + (uint256 positionSize,,) = squared.positions(address(this)); assertEq(1 ether, positionSize); } @@ -230,7 +230,7 @@ contract DepositTest is TestHelper { _mint(address(this), address(this), 10 ether); vm.warp(730 days + 1); - vm.expectRevert(Lendgine.CompleteUtilizationError.selector); - lendgine.deposit(cuh, 1 ether, bytes("")); + vm.expectRevert(Squared.CompleteUtilizationError.selector); + squared.deposit(cuh, 1 ether, bytes("")); } } diff --git a/test/FactoryTest.t.sol b/test/FactoryTest.t.sol index 42fd12b..6ddc5b7 100644 --- a/test/FactoryTest.t.sol +++ b/test/FactoryTest.t.sol @@ -2,19 +2,19 @@ pragma solidity ^0.8.0; import { Factory } from "../src/core/Factory.sol"; -import { Lendgine } from "../src/core/Lendgine.sol"; +import { Squared } from "../src/core/Squared.sol"; import { Test } from "forge-std/Test.sol"; -import { LendgineAddress } from "../src/periphery/libraries/LendgineAddress.sol"; +import { SquaredAddress } from "../src/periphery/libraries/SquaredAddress.sol"; contract FactoryTest is Test { - event LendgineCreated( + event SquaredCreated( address indexed token0, address indexed token1, uint256 token0Scale, uint256 token1Scale, uint256 indexed upperBound, - address lendgine + address squared ); Factory public factory; @@ -23,38 +23,38 @@ contract FactoryTest is Test { factory = new Factory(); } - function testGetLendgine() external { - address lendgine = factory.createLendgine(address(1), address(2), 18, 18, 1e18); + function testGetSquared() external { + address squared = factory.createSquared(address(1), address(2), 18, 18, 1e18); - assertEq(lendgine, factory.getLendgine(address(1), address(2), 18, 18, 1e18)); + assertEq(squared, factory.getSquared(address(1), address(2), 18, 18, 1e18)); } function testDeployAddress() external { - address lendgineEstimate = LendgineAddress.computeAddress(address(factory), address(1), address(2), 18, 18, 1e18); + address squaredEstimate = SquaredAddress.computeAddress(address(factory), address(1), address(2), 18, 18, 1e18); - address lendgine = factory.createLendgine(address(1), address(2), 18, 18, 1e18); + address squared = factory.createSquared(address(1), address(2), 18, 18, 1e18); - assertEq(lendgine, lendgineEstimate); + assertEq(squared, squaredEstimate); } function testSameTokenError() external { vm.expectRevert(Factory.SameTokenError.selector); - factory.createLendgine(address(1), address(1), 18, 18, 1e18); + factory.createSquared(address(1), address(1), 18, 18, 1e18); } function testZeroAddressError() external { vm.expectRevert(Factory.ZeroAddressError.selector); - factory.createLendgine(address(0), address(1), 18, 18, 1e18); + factory.createSquared(address(0), address(1), 18, 18, 1e18); vm.expectRevert(Factory.ZeroAddressError.selector); - factory.createLendgine(address(1), address(0), 18, 18, 1e18); + factory.createSquared(address(1), address(0), 18, 18, 1e18); } function testDeployedError() external { - factory.createLendgine(address(1), address(2), 18, 18, 1e18); + factory.createSquared(address(1), address(2), 18, 18, 1e18); vm.expectRevert(Factory.DeployedError.selector); - factory.createLendgine(address(1), address(2), 18, 18, 1e18); + factory.createSquared(address(1), address(2), 18, 18, 1e18); } function helpParametersZero() private { @@ -71,13 +71,13 @@ contract FactoryTest is Test { function testParameters() external { helpParametersZero(); - factory.createLendgine(address(1), address(2), 18, 18, 1e18); + factory.createSquared(address(1), address(2), 18, 18, 1e18); helpParametersZero(); } function testEmit() external { - address lendgineEstimate = address( + address squaredEstimate = address( uint160( uint256( keccak256( @@ -85,14 +85,14 @@ contract FactoryTest is Test { hex"ff", address(factory), keccak256(abi.encode(address(1), address(2), 18, 18, 1e18)), - keccak256(type(Lendgine).creationCode) + keccak256(type(Squared).creationCode) ) ) ) ) ); vm.expectEmit(true, true, true, true, address(factory)); - emit LendgineCreated(address(1), address(2), 18, 18, 1e18, lendgineEstimate); - factory.createLendgine(address(1), address(2), 18, 18, 1e18); + emit SquaredCreated(address(1), address(2), 18, 18, 1e18, squaredEstimate); + factory.createSquared(address(1), address(2), 18, 18, 1e18); } } diff --git a/test/ImmutableStateTest.t.sol b/test/ImmutableStateTest.t.sol index 5ae04c7..24557c2 100644 --- a/test/ImmutableStateTest.t.sol +++ b/test/ImmutableStateTest.t.sol @@ -2,23 +2,23 @@ pragma solidity ^0.8.0; import { Factory } from "../src/core/Factory.sol"; -import { Lendgine } from "../src/core/Lendgine.sol"; +import { Squared } from "../src/core/Squared.sol"; import { Test } from "forge-std/Test.sol"; contract ImmutableStateTest is Test { Factory public factory; - Lendgine public lendgine; + Squared public squared; function setUp() external { factory = new Factory(); - lendgine = Lendgine(factory.createLendgine(address(1), address(2), 18, 18, 1e18)); + squared = Squared(factory.createSquared(address(1), address(2), 18, 18, 1e18)); } function testImmutableState() external { - assertEq(address(1), lendgine.token0()); - assertEq(address(2), lendgine.token1()); - assertEq(1, lendgine.token0Scale()); - assertEq(1, lendgine.token1Scale()); - assertEq(1e18, lendgine.upperBound()); + assertEq(address(1), squared.token0()); + assertEq(address(2), squared.token1()); + assertEq(1, squared.token0Scale()); + assertEq(1, squared.token1Scale()); + assertEq(1e18, squared.upperBound()); } } diff --git a/test/LiquidityManagerTest.t.sol b/test/LiquidityManagerTest.t.sol index ada9152..4665b70 100644 --- a/test/LiquidityManagerTest.t.sol +++ b/test/LiquidityManagerTest.t.sol @@ -8,7 +8,7 @@ import { TestHelper } from "./utils/TestHelper.sol"; contract LiquidityManagerTest is TestHelper { event AddLiquidity( address indexed from, - address indexed lendgine, + address indexed squared, uint256 liquidity, uint256 size, uint256 amount0, @@ -18,7 +18,7 @@ contract LiquidityManagerTest is TestHelper { event RemoveLiquidity( address indexed from, - address indexed lendgine, + address indexed squared, uint256 liquidity, uint256 size, uint256 amount0, @@ -26,7 +26,7 @@ contract LiquidityManagerTest is TestHelper { address indexed to ); - event Collect(address indexed from, address indexed lendgine, uint256 amount, address indexed to); + event Collect(address indexed from, address indexed squared, uint256 amount, address indexed to); LiquidityManager public liquidityManager; @@ -70,14 +70,14 @@ contract LiquidityManagerTest is TestHelper { function testAddPositionEmpty() external { _addLiquidity(cuh, cuh, 1 ether, 8 ether, 1 ether); - // test lendgine storage - assertEq(lendgine.totalLiquidity(), 1 ether); - assertEq(lendgine.totalPositionSize(), 1 ether); - assertEq(lendgine.reserve0(), 1 ether); - assertEq(lendgine.reserve1(), 8 ether); + // test squared storage + assertEq(squared.totalLiquidity(), 1 ether); + assertEq(squared.totalPositionSize(), 1 ether); + assertEq(squared.reserve0(), 1 ether); + assertEq(squared.reserve1(), 8 ether); - // test lendgine position - (uint256 positionSize,,) = lendgine.positions(address(liquidityManager)); + // test squared position + (uint256 positionSize,,) = squared.positions(address(liquidityManager)); assertEq(1 ether, positionSize); // test balances @@ -85,7 +85,7 @@ contract LiquidityManagerTest is TestHelper { assertEq(0, token1.balanceOf(address(liquidityManager))); // test liquidity manager position - (positionSize,,) = liquidityManager.positions(cuh, address(lendgine)); + (positionSize,,) = liquidityManager.positions(cuh, address(squared)); assertEq(1 ether, positionSize); } @@ -94,14 +94,14 @@ contract LiquidityManagerTest is TestHelper { _addLiquidity(cuh, cuh, 1 ether, 8 ether, 1 ether); - // test lendgine storage - assertEq(lendgine.totalLiquidity(), 2 ether); - assertEq(lendgine.totalPositionSize(), 2 ether); - assertEq(lendgine.reserve0(), 2 ether); - assertEq(lendgine.reserve1(), 16 ether); + // test squared storage + assertEq(squared.totalLiquidity(), 2 ether); + assertEq(squared.totalPositionSize(), 2 ether); + assertEq(squared.reserve0(), 2 ether); + assertEq(squared.reserve1(), 16 ether); - // test lendgine position - (uint256 positionSize,,) = lendgine.positions(address(liquidityManager)); + // test squared position + (uint256 positionSize,,) = squared.positions(address(liquidityManager)); assertEq(1 ether, positionSize); // test balances @@ -109,7 +109,7 @@ contract LiquidityManagerTest is TestHelper { assertEq(0, token1.balanceOf(address(liquidityManager))); // test liquidity manager position - (positionSize,,) = liquidityManager.positions(cuh, address(lendgine)); + (positionSize,,) = liquidityManager.positions(cuh, address(squared)); assertEq(1 ether, positionSize); } @@ -170,19 +170,19 @@ contract LiquidityManagerTest is TestHelper { _addLiquidity(cuh, cuh, 1 ether, 8 ether, 1 ether); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year uint256 size = (1 ether * 1 ether) / (1 ether - lpDilution); - // test lendgine storage - assertEq(lendgine.totalLiquidity(), 1.5 ether); - assertEq(lendgine.totalPositionSize(), 1 ether + size); - assertEq(lendgine.reserve0(), 1.5 ether); - assertEq(lendgine.reserve1(), 12 ether); + // test squared storage + assertEq(squared.totalLiquidity(), 1.5 ether); + assertEq(squared.totalPositionSize(), 1 ether + size); + assertEq(squared.reserve0(), 1.5 ether); + assertEq(squared.reserve1(), 12 ether); - // test lendgine position + // test squared position (uint256 positionSize, uint256 rewardPerPositionPaid, uint256 tokensOwed) = - lendgine.positions(address(liquidityManager)); + squared.positions(address(liquidityManager)); assertEq(1 ether + size, positionSize); assertEq(10 * lpDilution, rewardPerPositionPaid); assertEq(10 * lpDilution, tokensOwed); @@ -192,7 +192,7 @@ contract LiquidityManagerTest is TestHelper { assertEq(0, token1.balanceOf(address(liquidityManager))); // test liquidity manager position - (positionSize, rewardPerPositionPaid, tokensOwed) = liquidityManager.positions(cuh, address(lendgine)); + (positionSize, rewardPerPositionPaid, tokensOwed) = liquidityManager.positions(cuh, address(squared)); assertEq(size + 1 ether, positionSize); assertEq(10 * lpDilution, rewardPerPositionPaid); assertEq(10 * lpDilution, tokensOwed); @@ -207,18 +207,18 @@ contract LiquidityManagerTest is TestHelper { _addLiquidity(cuh, cuh, 1 ether, 8 ether, 1 ether); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year uint256 size = (1 ether * 1 ether) / (1 ether - lpDilution); - // test lendgine storage - assertEq(lendgine.totalLiquidity(), 1.5 ether); - assertEq(lendgine.totalPositionSize(), 1 ether + size); - assertEq(lendgine.reserve0(), 1.5 ether); - assertEq(lendgine.reserve1(), 12 ether); + // test squared storage + assertEq(squared.totalLiquidity(), 1.5 ether); + assertEq(squared.totalPositionSize(), 1 ether + size); + assertEq(squared.reserve0(), 1.5 ether); + assertEq(squared.reserve1(), 12 ether); - // test lendgine position - (uint256 positionSize, uint256 rewardPerPositionPaid,) = lendgine.positions(address(liquidityManager)); + // test squared position + (uint256 positionSize, uint256 rewardPerPositionPaid,) = squared.positions(address(liquidityManager)); assertEq(1 ether + size, positionSize); assertEq(10 * lpDilution, rewardPerPositionPaid); @@ -227,7 +227,7 @@ contract LiquidityManagerTest is TestHelper { assertEq(0, token1.balanceOf(address(liquidityManager))); // test liquidity manager position - (positionSize, rewardPerPositionPaid,) = liquidityManager.positions(cuh, address(lendgine)); + (positionSize, rewardPerPositionPaid,) = liquidityManager.positions(cuh, address(squared)); assertEq(size, positionSize); assertEq(10 * lpDilution, rewardPerPositionPaid); } @@ -260,7 +260,7 @@ contract LiquidityManagerTest is TestHelper { token1.approve(address(liquidityManager), 8 ether); vm.expectEmit(true, true, true, true, address(liquidityManager)); - emit AddLiquidity(cuh, address(lendgine), 1 ether, 1 ether, 1 ether, 8 ether, cuh); + emit AddLiquidity(cuh, address(squared), 1 ether, 1 ether, 1 ether, 8 ether, cuh); liquidityManager.addLiquidity( LiquidityManager.AddLiquidityParams({ token0: address(token0), @@ -298,14 +298,14 @@ contract LiquidityManagerTest is TestHelper { }) ); - // test lendgine storage - assertEq(lendgine.totalLiquidity(), 0); - assertEq(lendgine.totalPositionSize(), 0); - assertEq(lendgine.reserve0(), 0); - assertEq(lendgine.reserve1(), 0); + // test squared storage + assertEq(squared.totalLiquidity(), 0); + assertEq(squared.totalPositionSize(), 0); + assertEq(squared.reserve0(), 0); + assertEq(squared.reserve1(), 0); - // test lendgine position - (uint256 positionSize,,) = lendgine.positions(address(liquidityManager)); + // test squared position + (uint256 positionSize,,) = squared.positions(address(liquidityManager)); assertEq(0, positionSize); // test balances @@ -313,7 +313,7 @@ contract LiquidityManagerTest is TestHelper { assertEq(0, token1.balanceOf(address(liquidityManager))); // test liquidity manager position - (positionSize,,) = liquidityManager.positions(cuh, address(lendgine)); + (positionSize,,) = liquidityManager.positions(cuh, address(squared)); assertEq(0, positionSize); } @@ -357,14 +357,14 @@ contract LiquidityManagerTest is TestHelper { }) ); - // test lendgine storage - assertEq(lendgine.totalLiquidity(), 0); - assertEq(lendgine.totalPositionSize(), 0); - assertEq(lendgine.reserve0(), 0); - assertEq(lendgine.reserve1(), 0); + // test squared storage + assertEq(squared.totalLiquidity(), 0); + assertEq(squared.totalPositionSize(), 0); + assertEq(squared.reserve0(), 0); + assertEq(squared.reserve1(), 0); - // test lendgine position - (uint256 positionSize,,) = lendgine.positions(address(liquidityManager)); + // test squared position + (uint256 positionSize,,) = squared.positions(address(liquidityManager)); assertEq(0, positionSize); // test balances @@ -372,7 +372,7 @@ contract LiquidityManagerTest is TestHelper { assertEq(8 ether, token1.balanceOf(address(liquidityManager))); // test liquidity manager position - (positionSize,,) = liquidityManager.positions(cuh, address(lendgine)); + (positionSize,,) = liquidityManager.positions(cuh, address(squared)); assertEq(0, positionSize); } @@ -403,7 +403,7 @@ contract LiquidityManagerTest is TestHelper { vm.prank(cuh); vm.expectEmit(true, true, true, true, address(liquidityManager)); - emit RemoveLiquidity(cuh, address(lendgine), 1 ether, 1 ether, 1 ether, 8 ether, cuh); + emit RemoveLiquidity(cuh, address(squared), 1 ether, 1 ether, 1 ether, 8 ether, cuh); liquidityManager.removeLiquidity( LiquidityManager.RemoveLiquidityParams({ token0: address(token0), @@ -441,17 +441,17 @@ contract LiquidityManagerTest is TestHelper { }) ); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year - // test lendgine storage - assertEq(lendgine.totalLiquidity(), lpDilution / 2); - assertEq(lendgine.totalPositionSize(), 0.5 ether); - assertEq(lendgine.reserve0(), lpDilution / 2); - assertEq(lendgine.reserve1(), lpDilution * 4); + // test squared storage + assertEq(squared.totalLiquidity(), lpDilution / 2); + assertEq(squared.totalPositionSize(), 0.5 ether); + assertEq(squared.reserve0(), lpDilution / 2); + assertEq(squared.reserve1(), lpDilution * 4); - // test lendgine position - (uint256 positionSize, uint256 rewardPerPositionPaid,) = lendgine.positions(address(liquidityManager)); + // test squared position + (uint256 positionSize, uint256 rewardPerPositionPaid,) = squared.positions(address(liquidityManager)); assertEq(0.5 ether, positionSize); assertEq(lpDilution * 10, rewardPerPositionPaid); @@ -460,7 +460,7 @@ contract LiquidityManagerTest is TestHelper { assertEq(0, token1.balanceOf(address(liquidityManager))); // test liquidity manager position - (positionSize, rewardPerPositionPaid,) = liquidityManager.positions(cuh, address(lendgine)); + (positionSize, rewardPerPositionPaid,) = liquidityManager.positions(cuh, address(squared)); assertEq(0.5 ether, positionSize); assertEq(lpDilution * 10, rewardPerPositionPaid); } @@ -470,24 +470,24 @@ contract LiquidityManagerTest is TestHelper { _mint(address(this), address(this), 5 ether); vm.warp(365 days + 1); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year vm.prank(cuh); liquidityManager.collect( - LiquidityManager.CollectParams({ lendgine: address(lendgine), recipient: cuh, amountRequested: lpDilution * 10 }) + LiquidityManager.CollectParams({ squared: address(squared), recipient: cuh, amountRequested: lpDilution * 10 }) ); - // test lendgine storage slots - assertEq(lpDilution * 10, lendgine.rewardPerPositionStored()); + // test squared storage slots + assertEq(lpDilution * 10, squared.rewardPerPositionStored()); - // test lendgine position - (, uint256 rewardPerPositionPaid, uint256 tokensOwed) = lendgine.positions(address(liquidityManager)); + // test squared position + (, uint256 rewardPerPositionPaid, uint256 tokensOwed) = squared.positions(address(liquidityManager)); assertEq(lpDilution * 10, rewardPerPositionPaid); assertEq(0, tokensOwed); // test liquidity manager position - (, rewardPerPositionPaid, tokensOwed) = liquidityManager.positions(cuh, address(lendgine)); + (, rewardPerPositionPaid, tokensOwed) = liquidityManager.positions(cuh, address(squared)); assertEq(lpDilution * 10, rewardPerPositionPaid); assertEq(0, tokensOwed); @@ -500,24 +500,24 @@ contract LiquidityManagerTest is TestHelper { _mint(address(this), address(this), 5 ether); vm.warp(365 days + 1); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year vm.prank(cuh); liquidityManager.collect( - LiquidityManager.CollectParams({ lendgine: address(lendgine), recipient: cuh, amountRequested: 100 ether }) + LiquidityManager.CollectParams({ squared: address(squared), recipient: cuh, amountRequested: 100 ether }) ); - // test lendgine storage slots - assertEq(lpDilution * 10, lendgine.rewardPerPositionStored()); + // test squared storage slots + assertEq(lpDilution * 10, squared.rewardPerPositionStored()); - // test lendgine position - (, uint256 rewardPerPositionPaid, uint256 tokensOwed) = lendgine.positions(address(liquidityManager)); + // test squared position + (, uint256 rewardPerPositionPaid, uint256 tokensOwed) = squared.positions(address(liquidityManager)); assertEq(lpDilution * 10, rewardPerPositionPaid); assertEq(0, tokensOwed); // test liquidity manager position - (, rewardPerPositionPaid, tokensOwed) = liquidityManager.positions(cuh, address(lendgine)); + (, rewardPerPositionPaid, tokensOwed) = liquidityManager.positions(cuh, address(squared)); assertEq(lpDilution * 10, rewardPerPositionPaid); assertEq(0, tokensOwed); @@ -530,13 +530,13 @@ contract LiquidityManagerTest is TestHelper { _mint(address(this), address(this), 5 ether); vm.warp(365 days + 1); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year vm.prank(cuh); liquidityManager.collect( LiquidityManager.CollectParams({ - lendgine: address(lendgine), + squared: address(squared), recipient: address(0), amountRequested: lpDilution * 10 }) @@ -551,14 +551,14 @@ contract LiquidityManagerTest is TestHelper { _mint(address(this), address(this), 5 ether); vm.warp(365 days + 1); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year vm.prank(cuh); vm.expectEmit(true, true, true, true, address(liquidityManager)); - emit Collect(cuh, address(lendgine), lpDilution * 10, cuh); + emit Collect(cuh, address(squared), lpDilution * 10, cuh); liquidityManager.collect( - LiquidityManager.CollectParams({ lendgine: address(lendgine), recipient: cuh, amountRequested: lpDilution * 10 }) + LiquidityManager.CollectParams({ squared: address(squared), recipient: cuh, amountRequested: lpDilution * 10 }) ); } } diff --git a/test/MintTest.t.sol b/test/MintTest.t.sol index e9ff36f..cd5a2a5 100644 --- a/test/MintTest.t.sol +++ b/test/MintTest.t.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only pragma solidity ^0.8.0; -import { Lendgine } from "../src/core/Lendgine.sol"; +import { Squared } from "../src/core/Squared.sol"; import { Pair } from "../src/core/Pair.sol"; import { TestHelper } from "./utils/TestHelper.sol"; @@ -18,20 +18,20 @@ contract MintTest is TestHelper { function testMintPartial() external { uint256 shares = _mint(cuh, cuh, 5 ether); - // check lendgine token + // check squared token assertEq(0.5 ether, shares); - assertEq(0.5 ether, lendgine.totalSupply()); - assertEq(0.5 ether, lendgine.balanceOf(cuh)); + assertEq(0.5 ether, squared.totalSupply()); + assertEq(0.5 ether, squared.balanceOf(cuh)); - // check lendgine storage slots - assertEq(0.5 ether, lendgine.totalLiquidityBorrowed()); - assertEq(0.5 ether, lendgine.totalLiquidity()); - assertEq(0.5 ether, uint256(lendgine.reserve0())); - assertEq(4 ether, uint256(lendgine.reserve1())); + // check squared storage slots + assertEq(0.5 ether, squared.totalLiquidityBorrowed()); + assertEq(0.5 ether, squared.totalLiquidity()); + assertEq(0.5 ether, uint256(squared.reserve0())); + assertEq(4 ether, uint256(squared.reserve1())); - // check lendgine balances - assertEq(0.5 ether, token0.balanceOf(address(lendgine))); - assertEq(4 ether + 5 ether, token1.balanceOf(address(lendgine))); + // check squared balances + assertEq(0.5 ether, token0.balanceOf(address(squared))); + assertEq(4 ether + 5 ether, token1.balanceOf(address(squared))); // check user balances assertEq(0.5 ether, token0.balanceOf(cuh)); @@ -41,20 +41,20 @@ contract MintTest is TestHelper { function testMintFull() external { uint256 shares = _mint(cuh, cuh, 10 ether); - // check lendgine token + // check squared token assertEq(1 ether, shares); - assertEq(1 ether, lendgine.totalSupply()); - assertEq(1 ether, lendgine.balanceOf(cuh)); + assertEq(1 ether, squared.totalSupply()); + assertEq(1 ether, squared.balanceOf(cuh)); - // check lendgine storage slots - assertEq(1 ether, lendgine.totalLiquidityBorrowed()); - assertEq(0, lendgine.totalLiquidity()); - assertEq(0, uint256(lendgine.reserve0())); - assertEq(0, uint256(lendgine.reserve1())); + // check squared storage slots + assertEq(1 ether, squared.totalLiquidityBorrowed()); + assertEq(0, squared.totalLiquidity()); + assertEq(0, uint256(squared.reserve0())); + assertEq(0, uint256(squared.reserve1())); - // check lendgine balances - assertEq(0, token0.balanceOf(address(lendgine))); - assertEq(10 ether, token1.balanceOf(address(lendgine))); + // check squared balances + assertEq(0, token0.balanceOf(address(squared))); + assertEq(10 ether, token1.balanceOf(address(squared))); // check user balances assertEq(1 ether, token0.balanceOf(cuh)); @@ -67,26 +67,26 @@ contract MintTest is TestHelper { } function testZeroMint() external { - vm.expectRevert(Lendgine.InputError.selector); - lendgine.mint(cuh, 0, bytes("")); + vm.expectRevert(Squared.InputError.selector); + squared.mint(cuh, 0, bytes("")); } function testOverMint() external { _mint(address(this), address(this), 5 ether); - vm.expectRevert(Lendgine.CompleteUtilizationError.selector); - lendgine.mint(cuh, 5 ether + 10, bytes("")); + vm.expectRevert(Squared.CompleteUtilizationError.selector); + squared.mint(cuh, 5 ether + 10, bytes("")); } - function testEmitLendgine() external { + function testEmitsquared() external { token1.mint(cuh, 5 ether); vm.prank(cuh); token1.approve(address(this), 5 ether); - vm.expectEmit(true, true, false, true, address(lendgine)); + vm.expectEmit(true, true, false, true, address(squared)); emit Mint(address(this), 5 ether, 0.5 ether, 0.5 ether, cuh); - lendgine.mint(cuh, 5 ether, abi.encode(MintCallbackData({ token: address(token1), payer: cuh }))); + squared.mint(cuh, 5 ether, abi.encode(MintCallbackData({ token: address(token1), payer: cuh }))); } function testEmitPair() external { @@ -95,9 +95,9 @@ contract MintTest is TestHelper { vm.prank(cuh); token1.approve(address(this), 5 ether); - vm.expectEmit(true, false, false, true, address(lendgine)); + vm.expectEmit(true, false, false, true, address(squared)); emit Burn(0.5 ether, 4 ether, 0.5 ether, cuh); - lendgine.mint(cuh, 5 ether, abi.encode(MintCallbackData({ token: address(token1), payer: cuh }))); + squared.mint(cuh, 5 ether, abi.encode(MintCallbackData({ token: address(token1), payer: cuh }))); } function testAccrueOnMint() external { @@ -105,8 +105,8 @@ contract MintTest is TestHelper { vm.warp(365 days + 1); _mint(cuh, cuh, 1 ether); - assertEq(365 days + 1, lendgine.lastUpdate()); - assert(lendgine.rewardPerPositionStored() != 0); + assertEq(365 days + 1, squared.lastUpdate()); + assert(squared.rewardPerPositionStored() != 0); } function testProportionalMint() external { @@ -114,27 +114,27 @@ contract MintTest is TestHelper { vm.warp(365 days + 1); uint256 shares = _mint(cuh, cuh, 1 ether); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year // check mint amount assertEq((0.1 ether * 0.5 ether) / (0.5 ether - lpDilution), shares); - assertEq(shares + 0.5 ether, lendgine.balanceOf(cuh)); + assertEq(shares + 0.5 ether, squared.balanceOf(cuh)); - // check lendgine storage slots - assertEq(0.6 ether - lpDilution, lendgine.totalLiquidityBorrowed()); - assertEq(shares + 0.5 ether, lendgine.totalSupply()); + // check squared storage slots + assertEq(0.6 ether - lpDilution, squared.totalLiquidityBorrowed()); + assertEq(shares + 0.5 ether, squared.totalSupply()); } function testNonStandardDecimals() external { token1Scale = 9; - lendgine = Lendgine(factory.createLendgine(address(token0), address(token1), token0Scale, token1Scale, upperBound)); + squared = Squared(factory.createSquared(address(token0), address(token1), token0Scale, token1Scale, upperBound)); token0.mint(address(this), 1e18); token1.mint(address(this), 8 * 1e9); - lendgine.deposit( + squared.deposit( address(this), 1 ether, abi.encode( @@ -152,22 +152,22 @@ contract MintTest is TestHelper { vm.prank(cuh); token1.approve(address(this), 5 * 1e9); - uint256 shares = lendgine.mint(cuh, 5 * 1e9, abi.encode(MintCallbackData({ token: address(token1), payer: cuh }))); + uint256 shares = squared.mint(cuh, 5 * 1e9, abi.encode(MintCallbackData({ token: address(token1), payer: cuh }))); - // check lendgine token + // check squared token assertEq(0.5 ether, shares); - assertEq(0.5 ether, lendgine.totalSupply()); - assertEq(0.5 ether, lendgine.balanceOf(cuh)); + assertEq(0.5 ether, squared.totalSupply()); + assertEq(0.5 ether, squared.balanceOf(cuh)); - // check lendgine storage slots - assertEq(0.5 ether, lendgine.totalLiquidityBorrowed()); - assertEq(0.5 ether, lendgine.totalLiquidity()); - assertEq(0.5 ether, uint256(lendgine.reserve0())); - assertEq(4 * 1e9, uint256(lendgine.reserve1())); + // check squared storage slots + assertEq(0.5 ether, squared.totalLiquidityBorrowed()); + assertEq(0.5 ether, squared.totalLiquidity()); + assertEq(0.5 ether, uint256(squared.reserve0())); + assertEq(4 * 1e9, uint256(squared.reserve1())); - // check lendgine balances - assertEq(0.5 ether, token0.balanceOf(address(lendgine))); - assertEq(9 * 1e9, token1.balanceOf(address(lendgine))); + // check squared balances + assertEq(0.5 ether, token0.balanceOf(address(squared))); + assertEq(9 * 1e9, token1.balanceOf(address(squared))); // check user balances assertEq(0.5 ether, token0.balanceOf(cuh)); @@ -178,7 +178,7 @@ contract MintTest is TestHelper { _mint(address(this), address(this), 5 ether); vm.warp(730 days + 1); - vm.expectRevert(Lendgine.CompleteUtilizationError.selector); - lendgine.mint(cuh, 1 ether, bytes("")); + vm.expectRevert(Squared.CompleteUtilizationError.selector); + squared.mint(cuh, 1 ether, bytes("")); } } diff --git a/test/PrecisionTest.t.sol b/test/PrecisionTest.t.sol index 87bdcf4..9a4b18d 100644 --- a/test/PrecisionTest.t.sol +++ b/test/PrecisionTest.t.sol @@ -2,7 +2,7 @@ pragma solidity ^0.8.0; import { Factory } from "../src/core/Factory.sol"; -import { Lendgine } from "../src/core/Lendgine.sol"; +import { Squared } from "../src/core/Squared.sol"; import { Pair } from "../src/core/Pair.sol"; import { TestHelper } from "./utils/TestHelper.sol"; @@ -25,7 +25,7 @@ contract PrecisionTest is TestHelper { } function testBaseline() external { - lendgine.invariant((upperBound * upperBound) / 1e18, 0, 1 ether); + squared.invariant((upperBound * upperBound) / 1e18, 0, 1 ether); uint256 value = (upperBound * upperBound) / 1e18; uint256 basePerDollar = 1e18; @@ -38,9 +38,9 @@ contract PrecisionTest is TestHelper { function testHighUpperBound() external { upperBound = 1e27; - lendgine = Lendgine(factory.createLendgine(address(token0), address(token1), token0Scale, token1Scale, upperBound)); + squared = Squared(factory.createSquared(address(token0), address(token1), token0Scale, token1Scale, upperBound)); - lendgine.invariant((upperBound * upperBound) / 1e18, 0, 1 ether); + squared.invariant((upperBound * upperBound) / 1e18, 0, 1 ether); uint256 value = (upperBound * upperBound) / 1e18; uint256 basePerDollar = 1e21; @@ -53,9 +53,9 @@ contract PrecisionTest is TestHelper { function testLowUpperBound() external { upperBound = 1e9; - lendgine = Lendgine(factory.createLendgine(address(token0), address(token1), token0Scale, token1Scale, upperBound)); + squared = Squared(factory.createSquared(address(token0), address(token1), token0Scale, token1Scale, upperBound)); - lendgine.invariant((upperBound * upperBound) / 1e18, 0, 1 ether); + squared.invariant((upperBound * upperBound) / 1e18, 0, 1 ether); uint256 value = (upperBound * upperBound) / 1e18; uint256 basePerDollar = 1e27; diff --git a/test/LendgineRouterTest.t.sol b/test/SquaredRouterTest.t.sol similarity index 71% rename from test/LendgineRouterTest.t.sol rename to test/SquaredRouterTest.t.sol index 38bcd91..9012bb7 100644 --- a/test/LendgineRouterTest.t.sol +++ b/test/SquaredRouterTest.t.sol @@ -1,8 +1,8 @@ // SPDX-License-Identifier: GPL-3.0-only pragma solidity ^0.8.0; -import { Lendgine } from "../src/core/Lendgine.sol"; -import { LendgineRouter } from "../src/periphery/LendgineRouter.sol"; +import { Squared } from "../src/core/Squared.sol"; +import { SquaredRouter } from "../src/periphery/SquaredRouter.sol"; import { SwapHelper } from "../src/periphery/SwapHelper.sol"; import { TestHelper } from "./utils/TestHelper.sol"; import { MockERC20 } from "./utils/mocks/MockERC20.sol"; @@ -12,12 +12,12 @@ import { IUniswapV2Pair } from "../src/periphery/UniswapV2/interfaces/IUniswapV2 import { IUniswapV3Factory } from "../src/periphery/UniswapV3/interfaces/IUniswapV3Factory.sol"; import { IUniswapV3Pool } from "../src/periphery/UniswapV3/interfaces/IUniswapV3Pool.sol"; -contract LendgineRouterTest is TestHelper { - event Mint(address indexed from, address indexed lendgine, uint256 collateral, uint256 shares, address indexed to); +contract SquaredRouterTest is TestHelper { + event Mint(address indexed from, address indexed squared, uint256 collateral, uint256 shares, address indexed to); - event Burn(address indexed from, address indexed lendgine, uint256 collateral, uint256 shares, address indexed to); + event Burn(address indexed from, address indexed squared, uint256 collateral, uint256 shares, address indexed to); - LendgineRouter public lendgineRouter; + SquaredRouter public squaredRouter; IUniswapV2Factory public uniswapV2Factory = IUniswapV2Factory(0xB7f907f7A9eBC822a80BD25E224be42Ce0A698A0); IUniswapV2Pair public uniswapV2Pair; @@ -32,7 +32,7 @@ contract LendgineRouterTest is TestHelper { vm.rollFork(2_244_070); //latest block _setUp(); - lendgineRouter = new LendgineRouter( + squaredRouter = new SquaredRouter( address(factory), address(uniswapV2Factory), address(uniswapV3Factory), @@ -60,8 +60,8 @@ contract LendgineRouterTest is TestHelper { vm.prank(0xb3A16C2B68BBB0111EbD27871a5934b949837D95); token1.transfer(cuh, 100 ether); - // deploy lendgine - lendgine = Lendgine(factory.createLendgine(address(token0), address(token1), 18, 18, 3 ether)); + // deploy squared + squared = Squared(factory.createSquared(address(token0), address(token1), 18, 18, 3 ether)); // deposit tokens vm.startPrank(cuh); @@ -70,7 +70,7 @@ contract LendgineRouterTest is TestHelper { vm.stopPrank(); // price is .735 weth / uni - lendgine.deposit( + squared.deposit( address(this), 10 ether, abi.encode( @@ -89,11 +89,11 @@ contract LendgineRouterTest is TestHelper { token1.mint(cuh, 1 ether); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - lendgineRouter.mint( - LendgineRouter.MintParams({ + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -110,35 +110,35 @@ contract LendgineRouterTest is TestHelper { ); // check option amounts - assertEq(0.1 ether, lendgine.totalSupply()); - assertEq(0.1 ether, lendgine.balanceOf(cuh)); + assertEq(0.1 ether, squared.totalSupply()); + assertEq(0.1 ether, squared.balanceOf(cuh)); // check uniswap // swap 0.1 ether of token 0 to token 1 assertEq(100.1 ether, token0.balanceOf(address(uniswapV2Pair))); assertApproxEqRel(99.9 ether, token1.balanceOf(address(uniswapV2Pair)), 0.001 ether); - // check lendgine storage - assertEq(0.1 ether, lendgine.totalLiquidityBorrowed()); + // check squared storage + assertEq(0.1 ether, squared.totalLiquidityBorrowed()); // check user balances assertApproxEqRel(0.9 ether, token1.balanceOf(cuh), 1 ether); // check router token balances - assertEq(0, token0.balanceOf(address(lendgineRouter))); - assertEq(0, token1.balanceOf(address(lendgineRouter))); - assertEq(0, lendgine.balanceOf(address(lendgineRouter))); + assertEq(0, token0.balanceOf(address(squaredRouter))); + assertEq(0, token1.balanceOf(address(squaredRouter))); + assertEq(0, squared.balanceOf(address(squaredRouter))); } function testMintBorrow() external { token1.mint(cuh, 1 ether); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - lendgineRouter.mint( - LendgineRouter.MintParams({ + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -155,24 +155,24 @@ contract LendgineRouterTest is TestHelper { ); // check option amounts - assertEq(0.98 ether, lendgine.totalSupply()); - assertEq(0.98 ether, lendgine.balanceOf(cuh)); + assertEq(0.98 ether, squared.totalSupply()); + assertEq(0.98 ether, squared.balanceOf(cuh)); // check uniswap // swap 0.98 ether of token 0 to token 1 assertEq(100.98 ether, token0.balanceOf(address(uniswapV2Pair))); assertApproxEqRel(99.02 ether, token1.balanceOf(address(uniswapV2Pair)), 0.001 ether); - // check lendgine storage - assertEq(0.98 ether, lendgine.totalLiquidityBorrowed()); + // check squared storage + assertEq(0.98 ether, squared.totalLiquidityBorrowed()); // check user balances assertApproxEqRel(0, token1.balanceOf(cuh), 1 ether); // check router token balances - assertEq(0, token0.balanceOf(address(lendgineRouter))); - assertEq(0, token1.balanceOf(address(lendgineRouter))); - assertEq(0, lendgine.balanceOf(address(lendgineRouter))); + assertEq(0, token0.balanceOf(address(squaredRouter))); + assertEq(0, token1.balanceOf(address(squaredRouter))); + assertEq(0, squared.balanceOf(address(squaredRouter))); } function testMintV3() external { @@ -182,11 +182,11 @@ contract LendgineRouterTest is TestHelper { uint256 balance1Before = token1.balanceOf(address(uniswapV3Pool)); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - lendgineRouter.mint( - LendgineRouter.MintParams({ + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: 18, @@ -203,33 +203,33 @@ contract LendgineRouterTest is TestHelper { ); // check option amounts - assertEq(0.2 ether, lendgine.totalSupply()); - assertEq(0.2 ether, lendgine.balanceOf(cuh)); + assertEq(0.2 ether, squared.totalSupply()); + assertEq(0.2 ether, squared.balanceOf(cuh)); // check uniswap // swap (1.2 / 6) * .540 ether of token 0 to token 1 assertApproxEqRel(balance0Before + 0.108 ether, token0.balanceOf(address(uniswapV3Pool)), 0.001 ether); assertApproxEqRel(balance1Before - 0.072 ether, token1.balanceOf(address(uniswapV3Pool)), 0.001 ether); - // check lendgine storage - assertEq(0.2 ether, lendgine.totalLiquidityBorrowed()); + // check squared storage + assertEq(0.2 ether, squared.totalLiquidityBorrowed()); // check router token balances - assertEq(0, token0.balanceOf(address(lendgineRouter))); - assertEq(0, token1.balanceOf(address(lendgineRouter))); - assertEq(0, lendgine.balanceOf(address(lendgineRouter))); + assertEq(0, token0.balanceOf(address(squaredRouter))); + assertEq(0, token1.balanceOf(address(squaredRouter))); + assertEq(0, squared.balanceOf(address(squaredRouter))); } function testAmountError() external { token1.mint(cuh, 1 ether); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - vm.expectRevert(LendgineRouter.AmountError.selector); - lendgineRouter.mint( - LendgineRouter.MintParams({ + vm.expectRevert(SquaredRouter.AmountError.selector); + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -250,12 +250,12 @@ contract LendgineRouterTest is TestHelper { token1.mint(cuh, 1 ether); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - vm.expectRevert(LendgineRouter.AmountError.selector); - lendgineRouter.mint( - LendgineRouter.MintParams({ + vm.expectRevert(SquaredRouter.AmountError.selector); + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -276,13 +276,13 @@ contract LendgineRouterTest is TestHelper { token1.mint(cuh, 1 ether); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - vm.expectEmit(true, true, true, true, address(lendgineRouter)); - emit Mint(cuh, address(lendgine), 1 ether, 0.1 ether, cuh); - lendgineRouter.mint( - LendgineRouter.MintParams({ + vm.expectEmit(true, true, true, true, address(squaredRouter)); + emit Mint(cuh, address(squared), 1 ether, 0.1 ether, cuh); + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -303,11 +303,11 @@ contract LendgineRouterTest is TestHelper { token1.mint(cuh, 1 ether); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - lendgineRouter.mint( - LendgineRouter.MintParams({ + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -324,11 +324,11 @@ contract LendgineRouterTest is TestHelper { ); vm.prank(cuh); - lendgine.approve(address(lendgineRouter), 0.98 ether); + squared.approve(address(squaredRouter), 0.98 ether); vm.prank(cuh); - lendgineRouter.burn( - LendgineRouter.BurnParams({ + squaredRouter.burn( + SquaredRouter.BurnParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -345,12 +345,12 @@ contract LendgineRouterTest is TestHelper { }) ); - // check lendgine token - assertEq(0, lendgine.balanceOf(cuh)); - assertEq(0, lendgine.totalSupply()); + // check squared token + assertEq(0, squared.balanceOf(cuh)); + assertEq(0, squared.totalSupply()); - // check lendgine storage slots - assertEq(0, lendgine.totalLiquidityBorrowed()); + // check squared storage slots + assertEq(0, squared.totalLiquidityBorrowed()); // check uniswap assertApproxEqRel(100 ether, token0.balanceOf(address(uniswapV2Pair)), 0.001 ether); @@ -360,20 +360,20 @@ contract LendgineRouterTest is TestHelper { assertApproxEqRel(0.1 ether, token1.balanceOf(cuh), 1 ether); // check router token balances - assertEq(0, token0.balanceOf(address(lendgineRouter))); - assertEq(0, token1.balanceOf(address(lendgineRouter))); - assertEq(0, lendgine.balanceOf(address(lendgineRouter))); + assertEq(0, token0.balanceOf(address(squaredRouter))); + assertEq(0, token1.balanceOf(address(squaredRouter))); + assertEq(0, squared.balanceOf(address(squaredRouter))); } function testBurnNoLiquidity() external { token1.mint(cuh, 1 ether); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - lendgineRouter.mint( - LendgineRouter.MintParams({ + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -392,11 +392,11 @@ contract LendgineRouterTest is TestHelper { _withdraw(address(this), address(this), 99.9 ether); vm.prank(cuh); - lendgine.approve(address(lendgineRouter), 0.1 ether); + squared.approve(address(squaredRouter), 0.1 ether); vm.prank(cuh); - lendgineRouter.burn( - LendgineRouter.BurnParams({ + squaredRouter.burn( + SquaredRouter.BurnParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -413,12 +413,12 @@ contract LendgineRouterTest is TestHelper { }) ); - // check lendgine token - assertEq(0, lendgine.balanceOf(cuh)); - assertEq(0, lendgine.totalSupply()); + // check squared token + assertEq(0, squared.balanceOf(cuh)); + assertEq(0, squared.totalSupply()); - // check lendgine storage slots - assertEq(0, lendgine.totalLiquidityBorrowed()); + // check squared storage slots + assertEq(0, squared.totalLiquidityBorrowed()); // check uniswap assertApproxEqRel(100 ether, token0.balanceOf(address(uniswapV2Pair)), 0.001 ether); @@ -428,9 +428,9 @@ contract LendgineRouterTest is TestHelper { assertApproxEqRel(0.1 ether, token1.balanceOf(cuh), 1 ether); // check router token balances - assertEq(0, token0.balanceOf(address(lendgineRouter))); - assertEq(0, token1.balanceOf(address(lendgineRouter))); - assertEq(0, lendgine.balanceOf(address(lendgineRouter))); + assertEq(0, token0.balanceOf(address(squaredRouter))); + assertEq(0, token1.balanceOf(address(squaredRouter))); + assertEq(0, squared.balanceOf(address(squaredRouter))); } function testBurnV3() external { @@ -442,11 +442,11 @@ contract LendgineRouterTest is TestHelper { uint256 userBalanceBefore = token1.balanceOf(cuh); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - lendgineRouter.mint( - LendgineRouter.MintParams({ + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: 18, @@ -463,11 +463,11 @@ contract LendgineRouterTest is TestHelper { ); vm.prank(cuh); - lendgine.approve(address(lendgineRouter), 0.2 ether); + squared.approve(address(squaredRouter), 0.2 ether); vm.prank(cuh); - lendgineRouter.burn( - LendgineRouter.BurnParams({ + squaredRouter.burn( + SquaredRouter.BurnParams({ token0: address(token0), token1: address(token1), token0Exp: 18, @@ -484,12 +484,12 @@ contract LendgineRouterTest is TestHelper { }) ); - // check lendgine token - assertEq(0, lendgine.balanceOf(cuh)); - assertEq(0, lendgine.totalSupply()); + // check squared token + assertEq(0, squared.balanceOf(cuh)); + assertEq(0, squared.totalSupply()); - // check lendgine storage slots - assertEq(0, lendgine.totalLiquidityBorrowed()); + // check squared storage slots + assertEq(0, squared.totalLiquidityBorrowed()); // check uniswap assertApproxEqRel(balance0Before, token0.balanceOf(address(uniswapV3Pool)), 0.001 ether); @@ -499,20 +499,20 @@ contract LendgineRouterTest is TestHelper { assertApproxEqRel(userBalanceBefore, token1.balanceOf(cuh), 0.001 ether); // check router token balances - assertEq(0, token0.balanceOf(address(lendgineRouter))); - assertEq(0, token1.balanceOf(address(lendgineRouter))); - assertEq(0, lendgine.balanceOf(address(lendgineRouter))); + assertEq(0, token0.balanceOf(address(squaredRouter))); + assertEq(0, token1.balanceOf(address(squaredRouter))); + assertEq(0, squared.balanceOf(address(squaredRouter))); } function testBurnEmit() external { token1.mint(cuh, 1 ether); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - lendgineRouter.mint( - LendgineRouter.MintParams({ + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -529,13 +529,13 @@ contract LendgineRouterTest is TestHelper { ); vm.prank(cuh); - lendgine.approve(address(lendgineRouter), 0.98 ether); + squared.approve(address(squaredRouter), 0.98 ether); vm.prank(cuh); - vm.expectEmit(true, true, true, true, address(lendgineRouter)); - emit Burn(cuh, address(lendgine), 9.8 ether, 0.98 ether, cuh); - lendgineRouter.burn( - LendgineRouter.BurnParams({ + vm.expectEmit(true, true, true, true, address(squaredRouter)); + emit Burn(cuh, address(squared), 9.8 ether, 0.98 ether, cuh); + squaredRouter.burn( + SquaredRouter.BurnParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -557,11 +557,11 @@ contract LendgineRouterTest is TestHelper { token1.mint(cuh, 1 ether); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - lendgineRouter.mint( - LendgineRouter.MintParams({ + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -578,12 +578,12 @@ contract LendgineRouterTest is TestHelper { ); vm.prank(cuh); - lendgine.approve(address(lendgineRouter), 0.98 ether); + squared.approve(address(squaredRouter), 0.98 ether); vm.prank(cuh); - vm.expectRevert(LendgineRouter.AmountError.selector); - lendgineRouter.burn( - LendgineRouter.BurnParams({ + vm.expectRevert(SquaredRouter.AmountError.selector); + squaredRouter.burn( + SquaredRouter.BurnParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -605,11 +605,11 @@ contract LendgineRouterTest is TestHelper { token1.mint(cuh, 1 ether); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - lendgineRouter.mint( - LendgineRouter.MintParams({ + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -626,12 +626,12 @@ contract LendgineRouterTest is TestHelper { ); vm.prank(cuh); - lendgine.approve(address(lendgineRouter), 0.98 ether); + squared.approve(address(squaredRouter), 0.98 ether); vm.prank(cuh); - vm.expectRevert(LendgineRouter.AmountError.selector); - lendgineRouter.burn( - LendgineRouter.BurnParams({ + vm.expectRevert(SquaredRouter.AmountError.selector); + squaredRouter.burn( + SquaredRouter.BurnParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -653,11 +653,11 @@ contract LendgineRouterTest is TestHelper { token1.mint(cuh, 1 ether); vm.prank(cuh); - token1.approve(address(lendgineRouter), 1 ether); + token1.approve(address(squaredRouter), 1 ether); vm.prank(cuh); - lendgineRouter.mint( - LendgineRouter.MintParams({ + squaredRouter.mint( + SquaredRouter.MintParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -676,11 +676,11 @@ contract LendgineRouterTest is TestHelper { uint256 balanceBefore = token1.balanceOf(address(cuh)); vm.prank(cuh); - lendgine.approve(address(lendgineRouter), 0.98 ether); + squared.approve(address(squaredRouter), 0.98 ether); vm.prank(cuh); - lendgineRouter.burn( - LendgineRouter.BurnParams({ + squaredRouter.burn( + SquaredRouter.BurnParams({ token0: address(token0), token1: address(token1), token0Exp: token0Scale, @@ -697,12 +697,12 @@ contract LendgineRouterTest is TestHelper { }) ); - // check lendgine token - assertEq(0, lendgine.balanceOf(cuh)); - assertEq(0, lendgine.totalSupply()); + // check squared token + assertEq(0, squared.balanceOf(cuh)); + assertEq(0, squared.totalSupply()); - // check lendgine storage slots - assertEq(0, lendgine.totalLiquidityBorrowed()); + // check squared storage slots + assertEq(0, squared.totalLiquidityBorrowed()); // check uniswap assertApproxEqRel(100 ether, token0.balanceOf(address(uniswapV2Pair)), 0.001 ether); @@ -712,8 +712,8 @@ contract LendgineRouterTest is TestHelper { assertEq(balanceBefore, token1.balanceOf(address(cuh))); // check router token balances - assertEq(0, token0.balanceOf(address(lendgineRouter))); - assertApproxEqRel(0.1 ether, token1.balanceOf(address(lendgineRouter)), 1 ether); - assertEq(0, lendgine.balanceOf(address(lendgineRouter))); + assertEq(0, token0.balanceOf(address(squaredRouter))); + assertApproxEqRel(0.1 ether, token1.balanceOf(address(squaredRouter)), 1 ether); + assertEq(0, squared.balanceOf(address(squaredRouter))); } } diff --git a/test/SwapTest.t.sol b/test/SwapTest.t.sol index d7b01aa..9ac1a66 100644 --- a/test/SwapTest.t.sol +++ b/test/SwapTest.t.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only pragma solidity ^0.8.0; -import { Lendgine } from "../src/core/Lendgine.sol"; +import { Squared } from "../src/core/Squared.sol"; import { Pair } from "../src/core/Pair.sol"; import { TestHelper } from "./utils/TestHelper.sol"; @@ -19,7 +19,7 @@ contract SwapTest is TestHelper { vm.prank(cuh); token0.approve(address(this), 24 ether); - lendgine.swap( + squared.swap( cuh, 0, 8 ether, @@ -32,9 +32,9 @@ contract SwapTest is TestHelper { assertEq(0, token0.balanceOf(cuh)); assertEq(8 ether, token1.balanceOf(cuh)); - // check lendgine storage slots - assertEq(25 ether, lendgine.reserve0()); - assertEq(0, lendgine.reserve1()); + // check squared storage slots + assertEq(25 ether, squared.reserve0()); + assertEq(0, squared.reserve1()); } function testUnderPay() external { @@ -44,7 +44,7 @@ contract SwapTest is TestHelper { token0.approve(address(this), 23 ether); vm.expectRevert(Pair.InvariantError.selector); - lendgine.swap( + squared.swap( cuh, 0, 8 ether, @@ -60,9 +60,9 @@ contract SwapTest is TestHelper { vm.prank(cuh); token0.approve(address(this), 24 ether); - vm.expectEmit(true, false, false, true, address(lendgine)); + vm.expectEmit(true, false, false, true, address(squared)); emit Swap(0, 8 ether, 24 ether, 0, cuh); - lendgine.swap( + squared.swap( cuh, 0, 8 ether, diff --git a/test/WithdrawTest.t.sol b/test/WithdrawTest.t.sol index abc7eed..4f06105 100644 --- a/test/WithdrawTest.t.sol +++ b/test/WithdrawTest.t.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only pragma solidity ^0.8.0; -import { Lendgine } from "../src/core/Lendgine.sol"; +import { Squared } from "../src/core/Squared.sol"; import { Pair } from "../src/core/Pair.sol"; import { TestHelper } from "./utils/TestHelper.sol"; import { FullMath } from "../src/libraries/FullMath.sol"; @@ -24,18 +24,18 @@ contract WithdrawTest is TestHelper { assertEq(0.5 ether, amount0); assertEq(4 ether, amount1); - assertEq(0.5 ether, lendgine.totalLiquidity()); - assertEq(0.5 ether, lendgine.totalPositionSize()); + assertEq(0.5 ether, squared.totalLiquidity()); + assertEq(0.5 ether, squared.totalPositionSize()); - assertEq(0.5 ether, uint256(lendgine.reserve0())); - assertEq(4 ether, uint256(lendgine.reserve1())); - assertEq(0.5 ether, token0.balanceOf(address(lendgine))); - assertEq(4 ether, token1.balanceOf(address(lendgine))); + assertEq(0.5 ether, uint256(squared.reserve0())); + assertEq(4 ether, uint256(squared.reserve1())); + assertEq(0.5 ether, token0.balanceOf(address(squared))); + assertEq(4 ether, token1.balanceOf(address(squared))); assertEq(0.5 ether, token0.balanceOf(address(cuh))); assertEq(4 ether, token1.balanceOf(address(cuh))); - (uint256 positionSize,,) = lendgine.positions(cuh); + (uint256 positionSize,,) = squared.positions(cuh); assertEq(0.5 ether, positionSize); } @@ -46,40 +46,40 @@ contract WithdrawTest is TestHelper { assertEq(1 ether, amount0); assertEq(8 ether, amount1); - assertEq(0, lendgine.totalLiquidity()); - assertEq(0, lendgine.totalPositionSize()); + assertEq(0, squared.totalLiquidity()); + assertEq(0, squared.totalPositionSize()); - assertEq(0, uint256(lendgine.reserve0())); - assertEq(0, uint256(lendgine.reserve1())); - assertEq(0, token0.balanceOf(address(lendgine))); - assertEq(0, token1.balanceOf(address(lendgine))); + assertEq(0, uint256(squared.reserve0())); + assertEq(0, uint256(squared.reserve1())); + assertEq(0, token0.balanceOf(address(squared))); + assertEq(0, token1.balanceOf(address(squared))); assertEq(1 ether, token0.balanceOf(address(cuh))); assertEq(8 ether, token1.balanceOf(address(cuh))); - (uint256 positionSize,,) = lendgine.positions(cuh); + (uint256 positionSize,,) = squared.positions(cuh); assertEq(0, positionSize); } - function testEmitLendgine() external { - vm.expectEmit(true, true, false, true, address(lendgine)); + function testEmitsquared() external { + vm.expectEmit(true, true, false, true, address(squared)); emit Withdraw(cuh, 1 ether, 1 ether, cuh); _withdraw(cuh, cuh, 1 ether); } function testEmitPair() external { - vm.expectEmit(true, false, false, true, address(lendgine)); + vm.expectEmit(true, false, false, true, address(squared)); emit Burn(1 ether, 8 ether, 1 ether, cuh); _withdraw(cuh, cuh, 1 ether); } function testZeroWithdraw() external { - vm.expectRevert(Lendgine.InputError.selector); + vm.expectRevert(Squared.InputError.selector); _withdraw(cuh, cuh, 0); } function testOverWithdraw() external { - vm.expectRevert(Lendgine.InsufficientPositionError.selector); + vm.expectRevert(Squared.InsufficientPositionError.selector); _withdraw(cuh, cuh, 2 ether); } @@ -91,7 +91,7 @@ contract WithdrawTest is TestHelper { function testCompleteUtilization() external { _mint(address(this), address(this), 5 ether); - vm.expectRevert(Lendgine.CompleteUtilizationError.selector); + vm.expectRevert(Squared.CompleteUtilizationError.selector); _withdraw(cuh, cuh, 0.5 ether + 1); } @@ -100,8 +100,8 @@ contract WithdrawTest is TestHelper { vm.warp(365 days + 1); _withdraw(cuh, cuh, 0.5 ether); - assertEq(365 days + 1, lendgine.lastUpdate()); - assert(lendgine.rewardPerPositionStored() != 0); + assertEq(365 days + 1, squared.lastUpdate()); + assert(squared.rewardPerPositionStored() != 0); } function testAccrueOnPositionWithdraw() external { @@ -109,7 +109,7 @@ contract WithdrawTest is TestHelper { vm.warp(365 days + 1); _withdraw(cuh, cuh, 0.5 ether); - (, uint256 rewardPerPositionPaid, uint256 tokensOwed) = lendgine.positions(cuh); + (, uint256 rewardPerPositionPaid, uint256 tokensOwed) = squared.positions(cuh); assert(rewardPerPositionPaid != 0); assert(tokensOwed != 0); } @@ -117,18 +117,18 @@ contract WithdrawTest is TestHelper { function testProportionalPositionSize() external { uint256 shares = _mint(address(this), address(this), 5 ether); vm.warp(365 days + 1); - lendgine.accrueInterest(); + squared.accrueInterest(); - uint256 borrowRate = lendgine.getBorrowRate(0.5 ether, 1 ether); + uint256 borrowRate = squared.getBorrowRate(0.5 ether, 1 ether); uint256 lpDilution = borrowRate / 2; // 0.5 lp for one year - uint256 reserve0 = lendgine.reserve0(); - uint256 reserve1 = lendgine.reserve1(); + uint256 reserve0 = squared.reserve0(); + uint256 reserve1 = squared.reserve1(); uint256 _amount0 = - FullMath.mulDivRoundingUp(reserve0, lendgine.convertShareToLiquidity(0.5 ether), lendgine.totalLiquidity()); + FullMath.mulDivRoundingUp(reserve0, squared.convertShareToLiquidity(0.5 ether), squared.totalLiquidity()); uint256 _amount1 = - FullMath.mulDivRoundingUp(reserve1, lendgine.convertShareToLiquidity(0.5 ether), lendgine.totalLiquidity()); + FullMath.mulDivRoundingUp(reserve1, squared.convertShareToLiquidity(0.5 ether), squared.totalLiquidity()); _burn(address(this), address(this), 0.5 ether, _amount0, _amount1); @@ -137,23 +137,23 @@ contract WithdrawTest is TestHelper { // check liquidity assertEq(liquidity, 1 ether - lpDilution); - // check lendgine storage slots - assertEq(lendgine.totalLiquidity(), 0); - assertEq(lendgine.totalPositionSize(), 0); - assertEq(lendgine.totalLiquidityBorrowed(), 0); - assertEq(0, lendgine.reserve0()); - assertEq(0, lendgine.reserve1()); + // check squared storage slots + assertEq(squared.totalLiquidity(), 0); + assertEq(squared.totalPositionSize(), 0); + assertEq(squared.totalLiquidityBorrowed(), 0); + assertEq(0, squared.reserve0()); + assertEq(0, squared.reserve1()); } function testNonStandardDecimals() external { token1Scale = 9; - lendgine = Lendgine(factory.createLendgine(address(token0), address(token1), token0Scale, token1Scale, upperBound)); + squared = Squared(factory.createSquared(address(token0), address(token1), token0Scale, token1Scale, upperBound)); token0.mint(address(this), 1e18); token1.mint(address(this), 8 * 1e9); - lendgine.deposit( + squared.deposit( address(this), 1 ether, abi.encode( @@ -167,24 +167,24 @@ contract WithdrawTest is TestHelper { ) ); - (uint256 amount0, uint256 amount1, uint256 liquidity) = lendgine.withdraw(address(this), 0.5 ether); + (uint256 amount0, uint256 amount1, uint256 liquidity) = squared.withdraw(address(this), 0.5 ether); assertEq(liquidity, 0.5 ether); assertEq(0.5 ether, amount0); assertEq(4 * 1e9, amount1); - assertEq(0.5 ether, lendgine.totalLiquidity()); - assertEq(0.5 ether, lendgine.totalPositionSize()); + assertEq(0.5 ether, squared.totalLiquidity()); + assertEq(0.5 ether, squared.totalPositionSize()); - assertEq(0.5 ether, uint256(lendgine.reserve0())); - assertEq(4 * 1e9, uint256(lendgine.reserve1())); - assertEq(0.5 ether, token0.balanceOf(address(lendgine))); - assertEq(4 * 1e9, token1.balanceOf(address(lendgine))); + assertEq(0.5 ether, uint256(squared.reserve0())); + assertEq(4 * 1e9, uint256(squared.reserve1())); + assertEq(0.5 ether, token0.balanceOf(address(squared))); + assertEq(4 * 1e9, token1.balanceOf(address(squared))); assertEq(0.5 ether, token0.balanceOf(address(this))); assertEq(4 * 1e9, token1.balanceOf(address(this))); - (uint256 positionSize,,) = lendgine.positions(address(this)); + (uint256 positionSize,,) = squared.positions(address(this)); assertEq(0.5 ether, positionSize); } } diff --git a/test/utils/TestHelper.sol b/test/utils/TestHelper.sol index 87526b5..e648d58 100644 --- a/test/utils/TestHelper.sol +++ b/test/utils/TestHelper.sol @@ -2,7 +2,7 @@ pragma solidity ^0.8.0; import { Factory } from "../../src/core/Factory.sol"; -import { Lendgine } from "../../src/core/Lendgine.sol"; +import { Squared } from "../../src/core/Squared.sol"; import { Test } from "forge-std/Test.sol"; import { CallbackHelper } from "./CallbackHelper.sol"; @@ -18,7 +18,7 @@ abstract contract TestHelper is Test, CallbackHelper { uint256 public upperBound; Factory public factory; - Lendgine public lendgine; + Squared public squared; address public cuh; address public dennis; @@ -46,7 +46,7 @@ abstract contract TestHelper is Test, CallbackHelper { (token0, token1) = address(tokenA) < address(tokenB) ? (tokenA, tokenB) : (tokenB, tokenA); factory = new Factory(); - lendgine = Lendgine(factory.createLendgine(address(token0), address(token1), token0Scale, token1Scale, upperBound)); + squared = Squared(factory.createSquared(address(token0), address(token1), token0Scale, token1Scale, upperBound)); } function _mint(address from, address to, uint256 collateral) internal returns (uint256 shares) { @@ -57,7 +57,7 @@ abstract contract TestHelper is Test, CallbackHelper { token1.approve(address(this), collateral); } - shares = lendgine.mint(to, collateral, abi.encode(MintCallbackData({ token: address(token1), payer: from }))); + shares = squared.mint(to, collateral, abi.encode(MintCallbackData({ token: address(token1), payer: from }))); } function _burn( @@ -72,15 +72,15 @@ abstract contract TestHelper is Test, CallbackHelper { { if (from != address(this)) { vm.startPrank(from); - lendgine.transfer(address(lendgine), shares); + squared.transfer(address(squared), shares); token0.approve(address(this), amount0); token1.approve(address(this), amount1); vm.stopPrank(); } else { - lendgine.transfer(address(lendgine), shares); + squared.transfer(address(squared), shares); } - collateral = lendgine.burn( + collateral = squared.burn( to, abi.encode( PairMintCallbackData({ @@ -114,7 +114,7 @@ abstract contract TestHelper is Test, CallbackHelper { vm.stopPrank(); } - size = lendgine.deposit( + size = squared.deposit( to, liquidity, abi.encode( @@ -138,6 +138,6 @@ abstract contract TestHelper is Test, CallbackHelper { returns (uint256 amount0, uint256 amount1, uint256 liquidity) { vm.prank(from); - (amount0, amount1, liquidity) = lendgine.withdraw(to, size); + (amount0, amount1, liquidity) = squared.withdraw(to, size); } }