Adapt tests to separate MMs

Apply minor enhancements

contracts/facets/Account/AccountFacetImpl.sol

@@ -131,7 +131,7 @@ library AccountFacetImpl {
         AccountStorage.Layout storage accountLayout = AccountStorage.layout();
         require(
             accountLayout.partyBAllocatedBalances[msg.sender][partyA] >= amount,
-            "PartyBFacet: Insufficient locked balance"
+            "PartyBFacet: Insufficient allocated balance"
         );
         LibMuon.verifyPartyBUpnl(upnlSig, msg.sender, partyA);
         int256 availableBalance = LibAccount.partyBAvailableForQuote(

contracts/facets/PartyA/PartyAFacetImpl.sol

@@ -52,7 +52,7 @@ library PartyAFacetImpl {
             lockedValues.totalForPartyA() <= notionalValue,
             "PartyAFacet: Leverage can't be lower than one"
         );
-        // TODO: shoud we check for partyB
+        // TODO: should we check for partyB
         require(
             lockedValues.lf >=
                 (symbolLayout.symbols[symbolId].minAcceptablePortionLF * lockedValues.totalForPartyA()) /

contracts/facets/PartyB/IPartyBEvents.sol

@@ -7,7 +7,7 @@ pragma solidity >=0.8.18;
 import "../../storages/QuoteStorage.sol";
 
 interface IPartyBEvents {
-    event LockQuote(address partyB, uint256 quoteId, QuoteStatus quoteStatus);
+    event LockQuote(address partyB, uint256 quoteId);
     event AllocatePartyB(address partyB, address partyA, uint256 amount);
     event UnlockQuote(address partyB, uint256 quoteId, QuoteStatus quoteStatus);
     event AcceptCancelRequest(uint256 quoteId, QuoteStatus quoteStatus);
@@ -16,8 +16,7 @@ interface IPartyBEvents {
         address partyA,
         address partyB,
         uint256 filledAmount,
-        uint256 openedPrice,
-        QuoteStatus quoteStatus
+        uint256 openedPrice
     );
     event FillCloseRequest(
         uint256 quoteId,

contracts/facets/PartyB/PartyBFacet.sol

@@ -19,7 +19,7 @@ contract PartyBFacet is Accessibility, Pausable, IPartyBEvents {
     ) external whenNotPartyBActionsPaused onlyPartyB notLiquidated(quoteId) {
         PartyBFacetImpl.lockQuote(quoteId, upnlSig, true);
         Quote storage quote = QuoteStorage.layout().quotes[quoteId];
-        emit LockQuote(quote.partyB, quoteId, quote.quoteStatus);
+        emit LockQuote(quote.partyB, quoteId);
     }
 
     function lockAndOpenQuote(
@@ -31,7 +31,7 @@ contract PartyBFacet is Accessibility, Pausable, IPartyBEvents {
     ) external whenNotPartyBActionsPaused onlyPartyB notLiquidated(quoteId) {
         Quote storage quote = QuoteStorage.layout().quotes[quoteId];
         PartyBFacetImpl.lockQuote(quoteId, upnlSig, false);
-        emit LockQuote(quote.partyB, quoteId, quote.quoteStatus);
+        emit LockQuote(quote.partyB, quoteId);
         uint256 newId = PartyBFacetImpl.openPosition(
             quoteId,
             filledAmount,
@@ -43,8 +43,7 @@ contract PartyBFacet is Accessibility, Pausable, IPartyBEvents {
             quote.partyA,
             quote.partyB,
             filledAmount,
-            openedPrice,
-            QuoteStatus.OPENED
+            openedPrice
         );
         if (newId != 0) {
             Quote storage newQuote = QuoteStorage.layout().quotes[newId];
@@ -104,8 +103,7 @@ contract PartyBFacet is Accessibility, Pausable, IPartyBEvents {
             quote.partyA,
             quote.partyB,
             filledAmount,
-            openedPrice,
-            QuoteStatus.OPENED
+            openedPrice
         );
         if (newId != 0) {
             Quote storage newQuote = QuoteStorage.layout().quotes[newId];

test/LiquidationFacet.behavior.ts

@@ -81,24 +81,24 @@ export function shouldBehaveLikeLiquidationFacet(): void {
       expect(balanceInfoOfPartyA.allocatedBalances).to.be.equal(
         decimal(500).sub(await getTradingFeeForQuotes(context, [1, 2, 3, 4])),
       );
-      expect(balanceInfoOfPartyA.totalLocked).to.be.equal(
+      expect(balanceInfoOfPartyA.totalLockedPartyA).to.be.equal(
         await getTotalLockedValuesForQuoteIds(context, [1]),
       );
       expect(balanceInfoOfPartyA.pendingLockedCva).to.be.equal("0");
-      expect(balanceInfoOfPartyA.pendingLockedMm).to.be.equal("0");
+      expect(balanceInfoOfPartyA.pendingLockedMmPartyA).to.be.equal("0");
       expect(balanceInfoOfPartyA.pendingLockedLf).to.be.equal("0");
-      expect(balanceInfoOfPartyA.totalPendingLocked).to.be.equal("0");
+      expect(balanceInfoOfPartyA.totalPendingLockedPartyA).to.be.equal("0");
 
       let balanceInfoOfPartyB: BalanceInfo = await this.hedger.getBalanceInfo(user);
       expect(balanceInfoOfPartyB.allocatedBalances).to.be.equal(decimal(360).toString());
       expect(balanceInfoOfPartyB.lockedCva).to.be.equal(decimal(22).toString());
-      expect(balanceInfoOfPartyB.lockedMm).to.be.equal(decimal(75).toString());
+      expect(balanceInfoOfPartyB.lockedMmPartyB).to.be.equal(decimal(40).toString());
       expect(balanceInfoOfPartyB.lockedLf).to.be.equal(decimal(3).toString());
-      expect(balanceInfoOfPartyB.totalLocked).to.be.equal(decimal(100).toString());
+      expect(balanceInfoOfPartyB.totalLockedPartyB).to.be.equal(decimal(65).toString());
       expect(balanceInfoOfPartyB.pendingLockedCva).to.be.equal("0");
-      expect(balanceInfoOfPartyB.pendingLockedMm).to.be.equal("0");
+      expect(balanceInfoOfPartyB.pendingLockedMmPartyB).to.be.equal("0");
       expect(balanceInfoOfPartyB.pendingLockedLf).to.be.equal("0");
-      expect(balanceInfoOfPartyB.totalPendingLocked).to.be.equal("0");
+      expect(balanceInfoOfPartyB.totalPendingLockedPartyB).to.be.equal("0");
     });
 
     it("Should fail to liquidate a user twice", async function() {
@@ -206,13 +206,13 @@ export function shouldBehaveLikeLiquidationFacet(): void {
       let balanceInfo: BalanceInfo = await this.hedger.getBalanceInfo(user);
       expect(balanceInfo.allocatedBalances).to.be.equal("0");
       expect(balanceInfo.lockedCva).to.be.equal("0");
-      expect(balanceInfo.lockedMm).to.be.equal("0");
+      expect(balanceInfo.lockedMmPartyB).to.be.equal("0");
       expect(balanceInfo.lockedLf).to.be.equal("0");
-      expect(balanceInfo.totalLocked).to.be.equal("0");
+      expect(balanceInfo.totalLockedPartyB).to.be.equal("0");
       expect(balanceInfo.pendingLockedCva).to.be.equal("0");
-      expect(balanceInfo.pendingLockedMm).to.be.equal("0");
+      expect(balanceInfo.pendingLockedMmPartyB).to.be.equal("0");
       expect(balanceInfo.pendingLockedLf).to.be.equal("0");
-      expect(balanceInfo.totalPendingLocked).to.be.equal("0");
+      expect(balanceInfo.totalPendingLockedPartyB).to.be.equal("0");
 
       expect((await context.viewFacet.getQuote(5)).quoteStatus).to.be.equal(QuoteStatus.CANCELED);
     });

test/SendQuote.behavior.ts

@@ -23,21 +23,21 @@ export function shouldBehaveLikeSendQuote(): void {
     const context: RunContext = this.context;
     await pausePartyA(context);
     await expect(
-      this.user.sendQuote(limitQuoteRequestBuilder().quantity(50).cva(50).mm(1).lf(100).build()),
+      this.user.sendQuote(limitQuoteRequestBuilder().quantity(50).cva(50).partyAmm(1).lf(100).build()),
     ).to.be.revertedWith("Pausable: PartyA actions paused");
   });
 
   it("Should fail on leverage being lower than one", async function() {
     await expect(
-      this.user.sendQuote(limitQuoteRequestBuilder().quantity(50).cva(50).mm(1).lf(100).build()),
+      this.user.sendQuote(limitQuoteRequestBuilder().quantity(50).cva(50).partyAmm(1).lf(100).build()),
     ).to.be.revertedWith("PartyAFacet: Leverage can't be lower than one");
 
     await expect(
       this.user.sendQuote(
         limitQuoteRequestBuilder()
           .quantity(decimal(0))
           .cva(decimal(3))
-          .mm(decimal(75))
+          .partyAmm(decimal(75))
           .lf(decimal(22))
           .build(),
       ),
@@ -51,7 +51,7 @@ export function shouldBehaveLikeSendQuote(): void {
           .symbolId(2)
           .quantity(decimal(0))
           .cva(decimal(3))
-          .mm(decimal(75))
+          .partyAmm(decimal(75))
           .lf(decimal(22))
           .build(),
       ),
@@ -64,7 +64,7 @@ export function shouldBehaveLikeSendQuote(): void {
         limitQuoteRequestBuilder()
           .quantity(decimal(100))
           .cva(decimal(1))
-          .mm(decimal(1))
+          .partyAmm(decimal(1))
           .lf(decimal(0))
           .build(),
       ),
@@ -77,7 +77,7 @@ export function shouldBehaveLikeSendQuote(): void {
         limitQuoteRequestBuilder()
           .quantity(decimal(50))
           .cva(decimal(1))
-          .mm(decimal(1))
+          .partyAmm(decimal(1))
           .lf(decimal(1))
           .build(),
       ),
@@ -91,7 +91,7 @@ export function shouldBehaveLikeSendQuote(): void {
           .partyBWhiteList([this.user.getAddress()])
           .quantity(decimal(50))
           .cva(decimal(3))
-          .mm(decimal(5))
+          .partyAmm(decimal(5))
           .lf(decimal(5))
           .build(),
       ),
@@ -105,7 +105,7 @@ export function shouldBehaveLikeSendQuote(): void {
           .price(decimal(16))
           .quantity(decimal(500))
           .cva(decimal(120))
-          .mm(this.user_allocated)
+          .partyAmm(this.user_allocated)
           .lf(decimal(50))
           .upnlSig(getDummySingleUpnlAndPriceSig(decimal(16)))
           .build(),
@@ -117,7 +117,7 @@ export function shouldBehaveLikeSendQuote(): void {
         limitQuoteRequestBuilder()
           .quantity(decimal(1600))
           .cva(decimal(250))
-          .mm(this.user_allocated)
+          .partyAmm(this.user_allocated)
           .lf(decimal(60))
           .build(),
       ),

test/SpecificScenario.behavior.ts

@@ -39,7 +39,8 @@ export function shouldBehaveLikeSpecificScenario(): void {
       Builder<QuoteRequest>()
         .partyBWhiteList([])
         .quantity("32000000000000000")
-        .mm("69706470325210735106")
+        .partyAmm("69706470325210735106")
+        .partyBmm("69706470325210735106")
         .cva("14394116573201404621")
         .lf("8104916153486468905")
         .price("22207600000000000000000")

test/models/EventListener.ts

@@ -99,11 +99,7 @@ export class EventListener {
     context.partyBFacet.on(Event.SEND_QUOTE, async (...args) => {
       let value: SendQuoteEventObject = args[args.length - 1].args;
       this.eventTrackQueues.get(Event.SEND_QUOTE)!.next(value);
-      if (value.quoteStatus == QuoteStatus.PENDING) {
-        this.queues.get(QuoteStatus.PENDING)!.next(value.quoteId);
-      } else {
-        this.queues.get(QuoteStatus.CANCELED)!.next(value.quoteId);
-      }
+      this.queues.get(QuoteStatus.PENDING)!.next(value.quoteId);
     });
     context.partyAFacet.on(Event.REQUEST_TO_CANCEL_QUOTE, async (...args) => {
       let value: RequestToCancelQuoteEventObject = args[args.length - 1].args;

test/models/Hedger.ts

@@ -104,13 +104,17 @@ export class Hedger {
     return {
       allocatedBalances: b[0],
       lockedCva: b[1],
-      lockedMm: b[2],
-      lockedLf: b[3],
-      totalLocked: b[4],
+      lockedLf: b[2],
+      lockedMmPartyA: b[3],
+      lockedMmPartyB: b[4],
+      totalLockedPartyA: b[1].add(b[2]).add(b[3]),
+      totalLockedPartyB: b[1].add(b[2]).add(b[4]),
       pendingLockedCva: b[5],
-      pendingLockedMm: b[6],
-      pendingLockedLf: b[7],
-      totalPendingLocked: b[8],
+      pendingLockedLf: b[6],
+      pendingLockedMmPartyA: b[7],
+      pendingLockedMmPartyB: b[8],
+      totalPendingLockedPartyA: b[5].add(b[6]).add(b[7]),
+      totalPendingLockedPartyB: b[5].add(b[6]).add(b[8]),
     };
   }
 
@@ -215,11 +219,16 @@ export class Hedger {
 export interface BalanceInfo {
   allocatedBalances: BigNumber;
   lockedCva: BigNumber;
-  lockedMm: BigNumber;
+  lockedMmPartyA: BigNumber;
+  lockedMmPartyB: BigNumber;
   lockedLf: BigNumber;
-  totalLocked: BigNumber;
+  totalLockedPartyA: BigNumber;
+  totalLockedPartyB: BigNumber;
   pendingLockedCva: BigNumber;
-  pendingLockedMm: BigNumber;
+  pendingLockedMmPartyA: BigNumber;
+  pendingLockedMmPartyB: BigNumber;
   pendingLockedLf: BigNumber;
-  totalPendingLocked: BigNumber;
+  totalPendingLockedPartyA: BigNumber;
+  totalPendingLockedPartyB: BigNumber;
 }
+

test/models/HedgerController.ts

@@ -226,7 +226,7 @@ export class HedgerController {
         await this.hedger.openPosition(
           quote.id,
           Builder<OpenRequest>()
-            .fillAmount(fillAmount)
+            .filledAmount(fillAmount)
             .openPrice(openPrice)
             .upnlPartyA(partyAUpnl)
             .upnlPartyB(partyBUpnl)
@@ -284,7 +284,7 @@ export class HedgerController {
         await this.hedger.fillCloseRequest(
           quote.id,
           Builder<FillCloseRequest>()
-            .fillAmount(fillAmount)
+            .filledAmount(fillAmount)
             .closedPrice(closePrice)
             .upnlPartyA(partyAUpnl)
             .upnlPartyB(partyBUpnl)

test/models/User.ts

@@ -6,7 +6,6 @@ import { PromiseOrValue } from "../../src/types/common";
 import { serializeToJson, unDecimal } from "../utils/Common";
 import { logger } from "../utils/LoggerUtils";
 import { getPrice } from "../utils/PriceUtils";
-import { getDummySingleUpnlAndPriceSig } from "../utils/SignatureUtils";
 import { QuoteStructOutput } from "../../src/types/contracts/facets/ViewFacet";
 import { PositionType } from "./Enums";
 import { RunContext } from "./RunContext";
@@ -62,8 +61,9 @@ export class User {
         request.price,
         request.quantity,
         request.cva,
-        request.mm,
         request.lf,
+        request.partyAmm,
+        request.partyBmm,
         request.maxFundingRate,
         request.deadline,
         await request.upnlSig,
@@ -90,13 +90,17 @@ export class User {
     return {
       allocatedBalances: b[0],
       lockedCva: b[1],
-      lockedMm: b[2],
-      lockedLf: b[3],
-      totalLocked: b[4],
+      lockedLf: b[2],
+      lockedMmPartyA: b[3],
+      lockedMmPartyB: b[4],
+      totalLockedPartyA: b[1].add(b[2]).add(b[3]),
+      totalLockedPartyB: b[1].add(b[2]).add(b[4]),
       pendingLockedCva: b[5],
-      pendingLockedMm: b[6],
-      pendingLockedLf: b[7],
-      totalPendingLocked: b[8],
+      pendingLockedLf: b[6],
+      pendingLockedMmPartyA: b[7],
+      pendingLockedMmPartyB: b[8],
+      totalPendingLockedPartyA: b[5].add(b[6]).add(b[7]),
+      totalPendingLockedPartyB: b[5].add(b[6]).add(b[8]),
     };
   }
 
@@ -172,13 +176,13 @@ export class User {
     if (upnl.gt(0)) {
       available = balanceInfo.allocatedBalances
         .add(upnl)
-        .sub(balanceInfo.totalLocked.add(balanceInfo.totalPendingLocked));
+        .sub(balanceInfo.totalLockedPartyA.add(balanceInfo.totalPendingLockedPartyA));
     } else {
-      let mm = balanceInfo.lockedMm;
+      let mm = balanceInfo.lockedMmPartyA;
       let mUpnl = upnl.mul(-1);
       let considering_mm = mUpnl.gt(mm) ? mUpnl : mm;
       available = balanceInfo.allocatedBalances
-        .sub(balanceInfo.lockedCva.add(balanceInfo.lockedLf).add(balanceInfo.totalPendingLocked))
+        .sub(balanceInfo.lockedCva.add(balanceInfo.lockedLf).add(balanceInfo.totalPendingLockedPartyA))
         .sub(considering_mm);
     }
     return available;
@@ -188,11 +192,15 @@ export class User {
 export interface BalanceInfo {
   allocatedBalances: BigNumber;
   lockedCva: BigNumber;
-  lockedMm: BigNumber;
+  lockedMmPartyA: BigNumber;
+  lockedMmPartyB: BigNumber;
   lockedLf: BigNumber;
-  totalLocked: BigNumber;
+  totalLockedPartyA: BigNumber;
+  totalLockedPartyB: BigNumber;
   pendingLockedCva: BigNumber;
-  pendingLockedMm: BigNumber;
+  pendingLockedMmPartyA: BigNumber;
+  pendingLockedMmPartyB: BigNumber;
   pendingLockedLf: BigNumber;
-  totalPendingLocked: BigNumber;
+  totalPendingLockedPartyA: BigNumber;
+  totalPendingLockedPartyB: BigNumber;
 }

test/models/UserController.ts

@@ -17,8 +17,8 @@ import { getPrice } from "../utils/PriceUtils";
 import { pick, randomBigNumber, randomBigNumberRatio } from "../utils/RandomUtils";
 import { roundToPrecision, safeDiv } from "../utils/SafeMath";
 import { getDummySingleUpnlAndPriceSig } from "../utils/SignatureUtils";
-import { QuoteStructOutput } from "./../../src/types/contracts/facets/ViewFacet";
-import { SymbolStructOutput } from "./../../src/types/contracts/facets/control/ControlFacet";
+import { QuoteStructOutput } from "../../src/types/contracts/facets/ViewFacet";
+import { SymbolStructOutput } from "../../src/types/contracts/facets/control/ControlFacet";
 import { Action, actionNamesMap, ActionWrapper, expandActions, userActionsMap } from "./Actions";
 import { OrderType, PositionType, QuoteStatus } from "./Enums";
 import { ManagedError } from "./ManagedError";
@@ -312,7 +312,8 @@ export class UserController {
       Builder<QuoteRequest>()
         .partyBWhiteList([])
         .quantity(quantity)
-        .mm(mm)
+        .partyAmm(mm)
+        .partyBmm(mm.div(2))
         .cva(cva)
         .lf(lf)
         .symbolId(symbol.symbolId)