Merge branch 'main' into max-oi-cap

markets/perps-market/contracts/interfaces/IAsyncOrderModule.sol

@@ -39,13 +39,6 @@ interface IAsyncOrderModule {
         uint256 acceptablePrice
     );
 
-    /*event OrderCancelled(
-        uint128 indexed marketId,
-        uint128 indexed asyncOrderId,
-        AsyncOrderClaim.Data asyncOrderClaim,
-        address indexed sender
-    );*/
-
     error OrderAlreadyCommitted(uint128 marketId, uint128 accountId);
     error SettlementStrategyNotFound(SettlementStrategy.Type strategyType);
     error OffchainLookup(

markets/perps-market/contracts/interfaces/IMarketConfigurationModule.sol

@@ -25,15 +25,15 @@ interface IMarketConfigurationModule {
     event FundingParametersSet(uint128 marketId, uint256 skewScale, uint256 maxFundingVelocity);
     event LiquidationParametersSet(
         uint128 marketId,
-        uint256 initialMarginFraction,
-        uint256 maintenanceMarginFraction,
+        uint256 initialMarginRatioD18,
+        uint256 maintenanceMarginRatioD18,
         uint256 liquidationRewardRatioD18,
         uint256 maxLiquidationLimitAccumulationMultiplier,
         uint256 maxSecondsInLiquidationWindow,
         uint256 minimumPositionMargin
     );
     event MaxMarketValueSet(uint128 marketId, uint256 maxMarketValue);
-    event LockedOiPercentSet(uint128 marketId, uint256 lockedOiPercent);
+    event LockedOiRatioD18Set(uint128 marketId, uint256 lockedOiRatioD18);
     event SettlementStrategyEnabled(uint128 marketId, uint256 strategyId, bool enabled);
 
     function addSettlementStrategy(
@@ -51,8 +51,8 @@ interface IMarketConfigurationModule {
 
     function setLiquidationParameters(
         uint128 marketId,
-        uint256 initialMarginFraction,
-        uint256 maintenanceMarginFraction,
+        uint256 initialMarginRatioD18,
+        uint256 maintenanceMarginRatioD18,
         uint256 liquidationRewardRatioD18,
         uint256 maxLiquidationLimitAccumulationMultiplier,
         uint256 maxSecondsInLiquidationWindow,
@@ -61,7 +61,7 @@ interface IMarketConfigurationModule {
 
     function setMaxMarketValue(uint128 marketId, uint256 maxMarketValue) external;
 
-    function setLockedOiPercent(uint128 marketId, uint256 lockedOiPercent) external;
+    function setLockedOiRatio(uint128 marketId, uint256 lockedOiRatioD18) external;
 
     function setSettlementStrategyEnabled(
         uint128 marketId,
@@ -80,8 +80,8 @@ interface IMarketConfigurationModule {
         external
         view
         returns (
-            uint256 initialMarginFraction,
-            uint256 maintenanceMarginFraction,
+            uint256 initialMarginRatioD18,
+            uint256 maintenanceMarginRatioD18,
             uint256 liquidationRewardRatioD18,
             uint256 maxLiquidationLimitAccumulationMultiplier,
             uint256 maxSecondsInLiquidationWindow
@@ -97,5 +97,5 @@ interface IMarketConfigurationModule {
         uint128 marketId
     ) external view returns (uint256 makerFee, uint256 takerFee);
 
-    function getLockedOiPercent(uint128 marketId) external view returns (uint256 lockedOiPercent);
+    function getLockedOiRatioD18(uint128 marketId) external view returns (uint256 lockedOiRatioD18);
 }

markets/perps-market/contracts/modules/MarketConfigurationModule.sol

@@ -72,8 +72,8 @@ contract MarketConfigurationModule is IMarketConfigurationModule {
 
     function setLiquidationParameters(
         uint128 marketId,
-        uint256 initialMarginFraction,
-        uint256 maintenanceMarginFraction,
+        uint256 initialMarginRatioD18,
+        uint256 maintenanceMarginRatioD18,
         uint256 liquidationRewardRatioD18,
         uint256 maxLiquidationLimitAccumulationMultiplier,
         uint256 maxSecondsInLiquidationWindow,
@@ -82,8 +82,8 @@ contract MarketConfigurationModule is IMarketConfigurationModule {
         PerpsMarket.load(marketId).onlyMarketOwner();
         PerpsMarketConfiguration.Data storage config = PerpsMarketConfiguration.load(marketId);
 
-        config.initialMarginFraction = initialMarginFraction;
-        config.maintenanceMarginFraction = maintenanceMarginFraction;
+        config.initialMarginRatioD18 = initialMarginRatioD18;
+        config.maintenanceMarginRatioD18 = maintenanceMarginRatioD18;
         config.liquidationRewardRatioD18 = liquidationRewardRatioD18;
         config
             .maxLiquidationLimitAccumulationMultiplier = maxLiquidationLimitAccumulationMultiplier;
@@ -92,20 +92,20 @@ contract MarketConfigurationModule is IMarketConfigurationModule {
 
         emit LiquidationParametersSet(
             marketId,
-            initialMarginFraction,
-            maintenanceMarginFraction,
+            initialMarginRatioD18,
+            maintenanceMarginRatioD18,
             liquidationRewardRatioD18,
             maxLiquidationLimitAccumulationMultiplier,
             maxSecondsInLiquidationWindow,
             minimumPositionMargin
         );
     }
 
-    function setLockedOiPercent(uint128 marketId, uint256 lockedOiPercent) external override {
+    function setLockedOiRatio(uint128 marketId, uint256 lockedOiRatioD18) external override {
         PerpsMarket.load(marketId).onlyMarketOwner();
         PerpsMarketConfiguration.Data storage config = PerpsMarketConfiguration.load(marketId);
-        config.lockedOiPercent = lockedOiPercent;
-        emit LockedOiPercentSet(marketId, lockedOiPercent);
+        config.lockedOiRatioD18 = lockedOiRatioD18;
+        emit LockedOiRatioD18Set(marketId, lockedOiRatioD18);
     }
 
     function getSettlementStrategy(
@@ -122,17 +122,17 @@ contract MarketConfigurationModule is IMarketConfigurationModule {
         view
         override
         returns (
-            uint256 initialMarginFraction,
-            uint256 maintenanceMarginFraction,
+            uint256 initialMarginRatioD18,
+            uint256 maintenanceMarginRatioD18,
             uint256 liquidationRewardRatioD18,
             uint256 maxLiquidationLimitAccumulationMultiplier,
             uint256 maxSecondsInLiquidationWindow
         )
     {
         PerpsMarketConfiguration.Data storage config = PerpsMarketConfiguration.load(marketId);
 
-        initialMarginFraction = config.initialMarginFraction;
-        maintenanceMarginFraction = config.maintenanceMarginFraction;
+        initialMarginRatioD18 = config.initialMarginRatioD18;
+        maintenanceMarginRatioD18 = config.maintenanceMarginRatioD18;
         liquidationRewardRatioD18 = config.liquidationRewardRatioD18;
         maxLiquidationLimitAccumulationMultiplier = config
             .maxLiquidationLimitAccumulationMultiplier;
@@ -165,9 +165,9 @@ contract MarketConfigurationModule is IMarketConfigurationModule {
         takerFee = config.orderFees.takerFee;
     }
 
-    function getLockedOiPercent(uint128 marketId) external view override returns (uint256) {
+    function getLockedOiRatioD18(uint128 marketId) external view override returns (uint256) {
         PerpsMarketConfiguration.Data storage config = PerpsMarketConfiguration.load(marketId);
 
-        return config.lockedOiPercent;
+        return config.lockedOiRatioD18;
     }
 }

markets/perps-market/contracts/modules/PerpsMarketFactoryModule.sol

@@ -95,7 +95,7 @@ contract PerpsMarketFactoryModule is IPerpsMarketFactoryModule {
     function minimumCredit(uint128 perpsMarketId) external view override returns (uint256) {
         return
             PerpsMarket.load(perpsMarketId).size.mulDecimal(
-                PerpsMarketConfiguration.load(perpsMarketId).lockedOiPercent
+                PerpsMarketConfiguration.load(perpsMarketId).lockedOiRatioD18
             );
     }
 

markets/perps-market/contracts/storage/PerpsAccount.sol

@@ -309,8 +309,8 @@ library PerpsAccount {
         uint128[] profitableMarkets;
         uint128[] losingMarkets;
         uint amountToDeposit;
-        uint amountToLiquidatePercentage;
-        uint percentageOfTotalLosingPnl;
+        uint amountToLiquidateRatioD18;
+        uint totalLosingPnlRatioD18;
         uint totalAvailableForDeposit;
     }
 
@@ -402,19 +402,19 @@ library PerpsAccount {
                     continue;
                 }
 
-                runtime.amountToLiquidatePercentage = amountToLiquidate.divDecimal(
+                runtime.amountToLiquidateRatioD18 = amountToLiquidate.divDecimal(
                     MathUtil.abs(oldPositionSize)
                 );
 
-                runtime.percentageOfTotalLosingPnl = MathUtil.abs(totalPnl).divDecimal(
+                runtime.totalLosingPnlRatioD18 = MathUtil.abs(totalPnl).divDecimal(
                     runtime.totalLosingPnl
                 );
                 runtime.totalAvailableForDeposit = totalAvailableUsd.mulDecimal(
-                    runtime.percentageOfTotalLosingPnl
+                    runtime.totalLosingPnlRatioD18
                 );
 
                 runtime.amountToDeposit = runtime.totalAvailableForDeposit.mulDecimal(
-                    runtime.amountToLiquidatePercentage
+                    runtime.amountToLiquidateRatioD18
                 );
 
                 runtime.amountToDeposit -= liquidationReward;

markets/perps-market/contracts/storage/PerpsMarketConfiguration.sol

@@ -26,14 +26,14 @@ library PerpsMarketConfiguration {
          * @dev the initial margin requirements for this market when opening a position
          * @dev this fraction is multiplied by the impact of the position on the skew (open position size / skewScale)
          */
-        uint256 initialMarginFraction;
+        uint256 initialMarginRatioD18;
         /**
          * @dev the maintenance margin requirements for this market when opening a position
          * @dev this generally will be lower than initial margin but is used to determine when to liquidate a position
          * @dev this fraction is multiplied by the impact of the position on the skew (position size / skewScale)
          */
-        uint256 maintenanceMarginFraction;
-        uint256 lockedOiPercent;
+        uint256 maintenanceMarginRatioD18;
+        uint256 lockedOiRatioD18;
         /**
          * @dev This multiplier is applied to the max liquidation value when calculating max liquidation for a given market
          */
@@ -95,8 +95,8 @@ library PerpsMarketConfiguration {
         uint256 sizeAbs = MathUtil.abs(size.to256());
         uint256 impactOnSkew = self.skewScale == 0 ? 0 : sizeAbs.divDecimal(self.skewScale);
 
-        initialMarginRatio = impactOnSkew.mulDecimal(self.initialMarginFraction);
-        maintenanceMarginRatio = impactOnSkew.mulDecimal(self.maintenanceMarginFraction);
+        initialMarginRatio = impactOnSkew.mulDecimal(self.initialMarginRatioD18);
+        maintenanceMarginRatio = impactOnSkew.mulDecimal(self.maintenanceMarginRatioD18);
 
         uint256 notional = sizeAbs.mulDecimal(price);
         initialMargin = notional.mulDecimal(initialMarginRatio);

markets/perps-market/storage.dump.sol

@@ -558,8 +558,8 @@ library PerpsAccount {
         uint128[] profitableMarkets;
         uint128[] losingMarkets;
         uint amountToDeposit;
-        uint amountToLiquidatePercentage;
-        uint percentageOfTotalLosingPnl;
+        uint amountToLiquidateRatioD18;
+        uint totalLosingPnlRatioD18;
         uint totalAvailableForDeposit;
     }
     function load(uint128 id) internal pure returns (Data storage account) {
@@ -604,9 +604,9 @@ library PerpsMarketConfiguration {
         uint256 maxMarketValue;
         uint256 maxFundingVelocity;
         uint256 skewScale;
-        uint256 initialMarginFraction;
-        uint256 maintenanceMarginFraction;
-        uint256 lockedOiPercent;
+        uint256 initialMarginRatioD18;
+        uint256 maintenanceMarginRatioD18;
+        uint256 lockedOiRatioD18;
         uint256 maxLiquidationLimitAccumulationMultiplier;
         uint256 maxSecondsInLiquidationWindow;
         uint256 liquidationRewardRatioD18;

markets/perps-market/test/integration/Market/MarketConfigration.test.ts

@@ -29,7 +29,7 @@ describe('MarketConfiguration', async () => {
     skewScale: bn(1),
     initialMarginFraction: bn(2),
     maintenanceMarginFraction: bn(10),
-    lockedOiPercent: bn(15),
+    lockedOiPercentRatioD18: bn(15),
     maxLiquidationLimitAccumulationMultiplier: bn(5),
     minimumPositionMargin: bn(50),
     liquidationRewardRatioD18: bn(10e9),
@@ -176,8 +176,12 @@ describe('MarketConfiguration', async () => {
     await assertEvent(
       await systems()
         .PerpsMarket.connect(marketOwner)
-        .setLockedOiPercent(marketId, fixture.lockedOiPercent),
-      'LockedOiPercentSet(' + marketId.toString() + ', ' + fixture.lockedOiPercent.toString() + ')',
+        .setLockedOiRatio(marketId, fixture.lockedOiPercentRatioD18),
+      'LockedOiRatioD18Set(' +
+        marketId.toString() +
+        ', ' +
+        fixture.lockedOiPercentRatioD18.toString() +
+        ')',
       systems().PerpsMarket
     );
   });
@@ -229,7 +233,7 @@ describe('MarketConfiguration', async () => {
     await assertRevert(
       systems()
         .PerpsMarket.connect(randomUser)
-        .setLockedOiPercent(marketId, fixture.lockedOiPercent),
+        .setLockedOiRatio(marketId, fixture.lockedOiPercentRatioD18),
       `OnlyMarketOwner("${owner}", "${randomUserAddress}")`
     );
   });

markets/perps-market/test/integration/Market/PerpsMarketModule.test.ts

@@ -41,7 +41,7 @@ describe('PerpsMarketModule', () => {
   });
 
   describe('getMarketSummary', () => {
-    beforeEach(() => restore());
+    beforeEach(restore);
 
     it('should return all values successfully', async () => {
       const summary = await systems().PerpsMarket.getMarketSummary(marketId);

markets/perps-market/test/integration/bootstrap/bootstrapPerpsMarkets.ts

@@ -35,7 +35,7 @@ export type PerpsMarketData = Array<{
     minimumPositionMargin: ethers.BigNumber;
   };
   maxMarketValue?: ethers.BigNumber;
-  lockedOiPercent?: ethers.BigNumber;
+  lockedOiRatioD18?: ethers.BigNumber;
   settlementStrategy?: Partial<{
     strategyType: ethers.BigNumber;
     settlementDelay: ethers.BigNumber;
@@ -89,7 +89,7 @@ export const bootstrapPerpsMarkets = (
       fundingParams,
       liquidationParams,
       maxMarketValue,
-      lockedOiPercent,
+      lockedOiRatioD18,
       settlementStrategy,
     }) => {
       let oracleNodeId: string, aggregator: AggregatorV3Mock, marketId: ethers.BigNumber;
@@ -158,11 +158,11 @@ export const bootstrapPerpsMarkets = (
         });
       }
 
-      if (lockedOiPercent) {
+      if (lockedOiRatioD18) {
         before('set locked oi percent', async () => {
-          await contracts.PerpsMarket.connect(marketOwner).setLockedOiPercent(
+          await contracts.PerpsMarket.connect(marketOwner).setLockedOiRatio(
             marketId,
-            lockedOiPercent
+            lockedOiRatioD18
           );
         });
       }