Add synthetic orderbook

package.json

@@ -14,7 +14,7 @@
   "devDependencies": {
     "@codechecks/client": "^0.1.10",
     "@defi-wonderland/smock": "^2.0.7",
-    "@equilibria/root": "2.3.0-rc8",
+    "@equilibria/root": "2.4.0-rc0",
     "@nomicfoundation/hardhat-chai-matchers": "^1.0.6",
     "@nomicfoundation/hardhat-network-helpers": "^1.0.8",
     "@nomicfoundation/hardhat-toolbox": "2.0.2",

packages/common/testutil/types.ts

@@ -1,5 +1,6 @@
 import { BigNumber, BigNumberish, utils, constants } from 'ethers'
 import { expect } from 'chai'
+import exp from 'constants'
 
 export interface OracleVersion {
   valid: boolean
@@ -45,8 +46,10 @@ export interface Order {
 
 export interface Guarantee {
   orders: BigNumberish
-  takerPos: BigNumberish
-  takerNeg: BigNumberish
+  longPos: BigNumberish
+  longNeg: BigNumberish
+  shortPos: BigNumberish
+  shortNeg: BigNumberish
   notional: BigNumberish
   takerFee: BigNumberish
   referral: BigNumberish
@@ -67,7 +70,6 @@ export interface Global {
   riskFee: BigNumberish
   latestPrice: BigNumberish
   pAccumulator: PAccumulator
-  exposure: BigNumberish
 }
 
 export interface Local {
@@ -80,14 +82,24 @@ export interface Local {
 export interface Version {
   valid: boolean
   price: BigNumberish
-  makerValue: Accumulator
-  longValue: Accumulator
-  shortValue: Accumulator
+  makerPosExposure: BigNumberish
+  makerNegExposure: BigNumberish
+  longPosExposure: BigNumberish
+  longNegExposure: BigNumberish
+  shortPosExposure: BigNumberish
+  shortNegExposure: BigNumberish
+  makerPreValue: Accumulator
+  longPreValue: Accumulator
+  shortPreValue: Accumulator
+  makerCloseValue: Accumulator
+  longCloseValue: Accumulator
+  shortCloseValue: Accumulator
+  longPostValue: Accumulator
+  shortPostValue: Accumulator
+  spreadPos: Accumulator
+  spreadNeg: Accumulator
   makerFee: Accumulator
   takerFee: Accumulator
-  makerOffset: Accumulator
-  takerPosOffset: Accumulator
-  takerNegOffset: Accumulator
   settlementFee: Accumulator
   liquidationFee: Accumulator
 }
@@ -110,10 +122,11 @@ export interface MarketParameter {
   settle: boolean
 }
 
-export interface AdiabaticFee {
-  linearFee: BigNumberish
-  proportionalFee: BigNumberish
-  adiabaticFee: BigNumberish
+export interface SynBook {
+  d0: BigNumberish
+  d1: BigNumberish
+  d2: BigNumberish
+  d3: BigNumberish
   scale: BigNumberish
 }
 
@@ -133,8 +146,7 @@ export interface PController {
 export interface RiskParameter {
   margin: BigNumberish
   maintenance: BigNumberish
-  takerFee: AdiabaticFee
-  makerFee: AdiabaticFee
+  synBook: SynBook
   makerLimit: BigNumberish
   efficiencyLimit: BigNumberish
   liquidationFee: BigNumberish
@@ -190,8 +202,10 @@ export function expectOrderEq(a: Order, b: Order): void {
 
 export function expectGuaranteeEq(a: Guarantee, b: Guarantee): void {
   expect(a.orders).to.equal(b.orders, 'Order:Orders')
-  expect(a.takerPos).to.equal(b.takerPos, 'Order:TakerPos')
-  expect(a.takerNeg).to.equal(b.takerNeg, 'Order:TakerNeg')
+  expect(a.longPos).to.equal(b.longPos, 'Order:LongPos')
+  expect(a.longNeg).to.equal(b.longNeg, 'Order:LongNeg')
+  expect(a.shortPos).to.equal(b.shortPos, 'Order:ShortPos')
+  expect(a.shortNeg).to.equal(b.shortNeg, 'Order:ShortNeg')
   expect(a.notional).to.equal(b.notional, 'Order:Notional')
   expect(a.takerFee).to.equal(b.takerFee, 'Order:TakerFee')
   expect(a.referral).to.equal(b.referral, 'Order:Referral')
@@ -211,7 +225,6 @@ export function expectGlobalEq(a: Global, b: Global): void {
   expect(a.oracleFee).to.equal(b.oracleFee, 'Global:OracleFee')
   expect(a.riskFee).to.equal(b.riskFee, 'Global:RiskFee')
   expect(a.latestPrice).to.equal(b.latestPrice, 'Global:LatestPrice')
-  expect(a.exposure).to.equal(b.exposure, 'Global:Exposure')
 }
 
 export function expectLocalEq(a: Local, b: Local): void {
@@ -224,14 +237,18 @@ export function expectLocalEq(a: Local, b: Local): void {
 export function expectVersionEq(a: Version, b: Version): void {
   expect(a.valid).to.equal(b.valid, 'Version:Valid')
   expect(a.price).to.equal(b.price, 'Version:Price')
-  expect(a.makerValue._value).to.equal(b.makerValue._value, 'Version:MakerValue')
-  expect(a.longValue._value).to.equal(b.longValue._value, 'Version:LongValue')
-  expect(a.shortValue._value).to.equal(b.shortValue._value, 'Version:ShortValue')
+  expect(a.makerPreValue._value).to.equal(b.makerPreValue._value, 'Version:MakerPreValue')
+  expect(a.longPreValue._value).to.equal(b.longPreValue._value, 'Version:LongPreValue')
+  expect(a.shortPreValue._value).to.equal(b.shortPreValue._value, 'Version:ShortPreValue')
+  expect(a.makerCloseValue._value).to.equal(b.makerCloseValue._value, 'Version:MakerCloseValue')
+  expect(a.longCloseValue._value).to.equal(b.longCloseValue._value, 'Version:LongCloseValue')
+  expect(a.shortCloseValue._value).to.equal(b.shortCloseValue._value, 'Version:ShortCloseValue')
+  expect(a.longPostValue._value).to.equal(b.longPostValue._value, 'Version:LongPostValue')
+  expect(a.shortPostValue._value).to.equal(b.shortPostValue._value, 'Version:ShortPostValue')
+  expect(a.spreadPos._value).to.equal(b.spreadPos._value, 'Version:SpreadPos')
+  expect(a.spreadNeg._value).to.equal(b.spreadNeg._value, 'Version:SpreadNeg')
   expect(a.makerFee._value).to.equal(b.makerFee._value, 'Version:MakerFee')
   expect(a.takerFee._value).to.equal(b.takerFee._value, 'Version:TakerFee')
-  expect(a.makerOffset._value).to.equal(b.makerOffset._value, 'Version:MakerOffset')
-  expect(a.takerPosOffset._value).to.equal(b.takerPosOffset._value, 'Version:TakerPosOffset')
-  expect(a.takerNegOffset._value).to.equal(b.takerNegOffset._value, 'Version:TakerNegOffset')
   expect(a.settlementFee._value).to.equal(b.settlementFee._value, 'Version:SettlementFee')
   expect(a.liquidationFee._value).to.equal(b.liquidationFee._value, 'Version:LiquidationFee')
 }
@@ -289,7 +306,6 @@ export const DEFAULT_GLOBAL: Global = {
     _value: 0,
     _skew: 0,
   },
-  exposure: 0,
 }
 
 export const DEFAULT_LOCAL: Local = {
@@ -316,8 +332,10 @@ export const DEFAULT_ORDER: Order = {
 
 export const DEFAULT_GUARANTEE: Guarantee = {
   orders: 0,
-  takerPos: 0,
-  takerNeg: 0,
+  longPos: 0,
+  longNeg: 0,
+  shortPos: 0,
+  shortNeg: 0,
   notional: 0,
   takerFee: 0,
   referral: 0,
@@ -326,14 +344,24 @@ export const DEFAULT_GUARANTEE: Guarantee = {
 export const DEFAULT_VERSION: Version = {
   valid: true,
   price: 0,
-  makerValue: { _value: 0 },
-  longValue: { _value: 0 },
-  shortValue: { _value: 0 },
+  makerPosExposure: 0,
+  makerNegExposure: 0,
+  longPosExposure: 0,
+  longNegExposure: 0,
+  shortPosExposure: 0,
+  shortNegExposure: 0,
+  makerPreValue: { _value: 0 },
+  longPreValue: { _value: 0 },
+  shortPreValue: { _value: 0 },
+  makerCloseValue: { _value: 0 },
+  longCloseValue: { _value: 0 },
+  shortCloseValue: { _value: 0 },
+  longPostValue: { _value: 0 },
+  shortPostValue: { _value: 0 },
+  spreadPos: { _value: 0 },
+  spreadNeg: { _value: 0 },
   makerFee: { _value: 0 },
   takerFee: { _value: 0 },
-  makerOffset: { _value: 0 },
-  takerPosOffset: { _value: 0 },
-  takerNegOffset: { _value: 0 },
   settlementFee: { _value: 0 },
   liquidationFee: { _value: 0 },
 }
@@ -362,10 +390,11 @@ export const DEFAULT_MARKET_PARAMETER: MarketParameter = {
   settle: false,
 }
 
-export const DEFAULT_ADIABATIC_FEE: AdiabaticFee = {
-  linearFee: 0,
-  proportionalFee: 0,
-  adiabaticFee: 0,
+export const DEFAULT_SYN_BOOK: SynBook = {
+  d0: 0,
+  d1: 0,
+  d2: 0,
+  d3: 0,
   scale: 0,
 }
 
@@ -385,8 +414,7 @@ export const DEFAULT_PCONTROLLER: PController = {
 export const DEFAULT_RISK_PARAMETER: RiskParameter = {
   margin: 0,
   maintenance: 0,
-  takerFee: DEFAULT_ADIABATIC_FEE,
-  makerFee: DEFAULT_ADIABATIC_FEE,
+  synBook: DEFAULT_SYN_BOOK,
   makerLimit: 0,
   efficiencyLimit: 0,
   liquidationFee: 0,

packages/core/contracts/Market.sol

@@ -334,19 +334,7 @@ contract Market is IMarket, Instance, ReentrancyGuard {
     /// @notice Updates the risk parameter set of the market
     /// @param newRiskParameter The new risk parameter set
     function updateRiskParameter(RiskParameter memory newRiskParameter) external onlyCoordinator {
-        // load latest state
-        Global memory newGlobal = _global.read();
-        Position memory latestPosition = _position.read();
-        RiskParameter memory latestRiskParameter = _riskParameter.read();
-
-        // update risk parameter (first to capture truncation)
         _riskParameter.validateAndStore(newRiskParameter, IMarketFactory(address(factory())).parameter());
-        newRiskParameter = _riskParameter.read();
-
-        // update global exposure
-        newGlobal.update(latestRiskParameter, newRiskParameter, latestPosition);
-        _global.store(newGlobal);
-
         emit RiskParameterUpdated(newRiskParameter);
     }
 
@@ -388,20 +376,6 @@ contract Market is IMarket, Instance, ReentrancyGuard {
         }
     }
 
-    /// @notice Settles any exposure that has accrued to the market
-    /// @dev Resets exposure to zero, caller pays or receives to net out the exposure
-    function claimExposure() external onlyOwner {
-        Global memory newGlobal = _global.read();
-
-        if (newGlobal.exposure.sign() == 1) token.push(msg.sender, UFixed18Lib.from(newGlobal.exposure.abs()));
-        if (newGlobal.exposure.sign() == -1) token.pull(msg.sender, UFixed18Lib.from(newGlobal.exposure.abs()));
-
-        emit ExposureClaimed(msg.sender, newGlobal.exposure);
-
-        newGlobal.exposure = Fixed6Lib.ZERO;
-        _global.store(newGlobal);
-    }
-
     /// @notice Returns the current parameter set
     function parameter() external view returns (MarketParameter memory) {
         return _parameter.read();

packages/core/contracts/interfaces/IMarket.sol

@@ -73,7 +73,6 @@ interface IMarket is IInstance {
     /// @param receiver Delegated operator of the account, or the account itself
     /// @param amount Collateral transferred from market to receiver
     event FeeClaimed(address indexed account, address indexed receiver, UFixed6 amount);
-    event ExposureClaimed(address indexed account, Fixed6 amount);
     event ParameterUpdated(MarketParameter newParameter);
     event RiskParameterUpdated(RiskParameter newRiskParameter);
 

packages/core/contracts/libs/CheckpointLib.sol

@@ -35,8 +35,8 @@ struct CheckpointAccumulationResult {
     /// @dev Trade fee accumulated for this checkpoint
     UFixed6 tradeFee;
 
-    /// @dev Trade price impact accumulated for this checkpoint
-    Fixed6 offset;
+    /// @dev Spread accumulated for this checkpoint
+    Fixed6 spread;
 
     /// @dev Settlement fee charged for this checkpoint
     UFixed6 settlementFee;
@@ -73,10 +73,10 @@ library CheckpointLib {
         CheckpointAccumulationResult memory result;
 
         // accumulate
-        result.collateral = _accumulateCollateral(context.latestPositionLocal, fromVersion, toVersion);
+        result.collateral = _accumulateCollateral(context.latestPositionLocal, order, fromVersion, toVersion);
         result.priceOverride = _accumulatePriceOverride(guarantee, toVersion);
         (result.tradeFee, result.subtractiveFee, result.solverFee) = _accumulateFee(order, guarantee, toVersion);
-        result.offset = _accumulateOffset(order, guarantee, toVersion);
+        result.spread = _accumulateSpread(order, guarantee, toVersion);
         result.settlementFee = _accumulateSettlementFee(order, guarantee, toVersion);
         result.liquidationFee = _accumulateLiquidationFee(order, toVersion);
 
@@ -89,7 +89,7 @@ library CheckpointLib {
             .add(result.collateral)                                                 // incorporate collateral change at this settlement
             .add(result.priceOverride);                                             // incorporate price override pnl at this settlement
         next.transfer = order.collateral;
-        next.tradeFee = Fixed6Lib.from(result.tradeFee).add(result.offset);
+        next.tradeFee = Fixed6Lib.from(result.tradeFee).add(result.spread);
         next.settlementFee = result.settlementFee.add(result.liquidationFee);
 
         emit IMarket.AccountPositionProcessed(context.account, orderId, order, result);
@@ -106,7 +106,7 @@ library CheckpointLib {
         response.collateral = result.collateral
             .add(result.priceOverride)
             .sub(Fixed6Lib.from(result.tradeFee))
-            .sub(result.offset)
+            .sub(result.spread)
             .sub(Fixed6Lib.from(result.settlementFee));
         response.liquidationFee = result.liquidationFee;
         response.subtractiveFee = result.subtractiveFee;
@@ -119,12 +119,34 @@ library CheckpointLib {
     /// @param toVersion The next version
     function _accumulateCollateral(
         Position memory fromPosition,
+        Order memory order,
         Version memory fromVersion,
         Version memory toVersion
-    ) private pure returns (Fixed6) {
-        return toVersion.makerValue.accumulated(fromVersion.makerValue, fromPosition.maker)
-            .add(toVersion.longValue.accumulated(fromVersion.longValue, fromPosition.long))
-            .add(toVersion.shortValue.accumulated(fromVersion.shortValue, fromPosition.short));
+    ) private pure returns (Fixed6 collateral) {
+        // calculate position after closes
+        Position memory closedPosition = fromPosition.clone();
+        closedPosition.updateClose(order);
+
+        // calculate position after order
+        Position memory toPosition = fromPosition.clone();
+        toPosition.update(order);
+
+        // collateral change pre position change
+        collateral = collateral
+            .add(toVersion.makerPreValue.accumulated(fromVersion.makerPreValue, fromPosition.maker))
+            .add(toVersion.longPreValue.accumulated(fromVersion.longPreValue, fromPosition.long))
+            .add(toVersion.shortPreValue.accumulated(fromVersion.shortPreValue, fromPosition.short));
+
+       // collateral change after applying closing portion of order
+        collateral = collateral
+            .add(toVersion.makerCloseValue.accumulated(fromVersion.makerCloseValue, closedPosition.maker))
+            .add(toVersion.longCloseValue.accumulated(fromVersion.longCloseValue, closedPosition.long))
+            .add(toVersion.shortCloseValue.accumulated(fromVersion.shortCloseValue, closedPosition.short));
+
+        // collateral change after applying entire order
+        collateral = collateral
+            .add(toVersion.longPostValue.accumulated(fromVersion.longPostValue, toPosition.long))
+            .add(toVersion.shortPostValue.accumulated(fromVersion.shortPostValue, toPosition.short));
     }
 
     /// @notice Accumulate trade fees for the next position
@@ -161,26 +183,23 @@ library CheckpointLib {
 
         tradeFee = makerFee.add(takerFee);
         subtractiveFee = makerSubtractiveFee.add(takerSubtractiveFee).sub(solverFee);
-
     }
 
-    /// @notice Accumulate price offset for the next position
-    /// @dev This includes adjustment for linear, proportional, and adiabatic order fees
+    /// @notice Accumulate spread charged for the next position
     /// @param order The next order
     /// @param guarantee The next guarantee
     /// @param toVersion The next version
-    function _accumulateOffset(
+    function _accumulateSpread(
         Order memory order,
         Guarantee memory guarantee,
         Version memory toVersion
     ) private pure returns (Fixed6) {
-        (UFixed6 takerPos, UFixed6 takerNeg) =
-            (order.takerPos().sub(guarantee.takerPos), order.takerNeg().sub(guarantee.takerNeg));
+        (UFixed6 exposurePos, UFixed6 exposureNeg) = order.exposure(guarantee, toVersion);
 
+        // flip sign because we want the accumulator to round up correctly, but need charged spread to be positive
         return Fixed6Lib.ZERO
-            .sub(toVersion.makerOffset.accumulated(Accumulator6(Fixed6Lib.ZERO), order.makerTotal()))
-            .sub(toVersion.takerPosOffset.accumulated(Accumulator6(Fixed6Lib.ZERO), takerPos))
-            .sub(toVersion.takerNegOffset.accumulated(Accumulator6(Fixed6Lib.ZERO), takerNeg));
+            .sub(toVersion.spreadPos.accumulated(Accumulator6(Fixed6Lib.ZERO), exposurePos))
+            .sub(toVersion.spreadNeg.accumulated(Accumulator6(Fixed6Lib.ZERO), exposureNeg));
     }