@indigo-labs/indigo-sdk 0.4.4 → 0.5.1

package/src/contracts/stableswap/helpers.ts

@@ -1,9 +1,60 @@
-import { fromHex, fromText, OutRef } from '@lucid-evolution/lucid';
-import { serialiseStableswapOutputDatum } from './types-new';
+import {
+  Assets,
+  fromHex,
+  fromText,
+  LucidEvolution,
+  OutRef,
+  toHex,
+} from '@lucid-evolution/lucid';
+import { array as A, ord as Ord, function as F } from 'fp-ts';
+import {
+  serialiseStableswapOutputDatum,
+  StableswapOrderDatum,
+} from './types-new';
 import { Data } from '@evolution-sdk/evolution';
+import { ParsedOutput } from '../../types/generic';
+import {
+  addressToBech32,
+  assetClassValueOf,
+  lovelacesAmt,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { SystemParams } from '../../types/system-params';
+import { StableswapPoolContent } from '../cdp/types-new';
+import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
+import {
+  rationalDiv,
+  rationalFloor,
+  rationalFromInt,
+  rationalMul,
+  rationalToFloat,
+} from '../../types/rational';
+import { BigIntOrd } from '../../utils/bigint-utils';
+import { estimateUtxoMinLovelace } from '../../utils/lucid-utils';
 
 export const BASE_MAX_EXECUTION_FEE = 1_620_000n;
 
+export type PSMProcessingConfig = {
+  /**
+   * Whether to enforce that an order has max execution fee satisfying
+   * min threshold (i.e. the processor might be paying the remaining cardano tx fee).
+   *
+   * In case, owner wants to process such order himself, he can ignore the constraint.
+   * @default true
+   */
+  enforceMaxExecutionFeeConstraint?: boolean;
+  /**
+   * Whether to enforce the minimum lovelace constraint. If not enforced,
+   * the processor might need to pay the min lovelace for the order output.
+   * @default true
+   */
+  enforceMinLovelaceConstraint?: boolean;
+};
+
+const defaultPSMProcessingConfig: PSMProcessingConfig = {
+  enforceMaxExecutionFeeConstraint: true,
+  enforceMinLovelaceConstraint: true,
+};
+
 export function createDestinationDatum(
   datum: Data.Data | null,
   outRef: OutRef,
@@ -20,3 +71,437 @@ export function createDestinationDatum(
 
   return Data.toCBORHex(datum);
 }
+
+export type StableswapInfo = {
+  suppliedIasset: bigint;
+  suppliedCollateralAsset: bigint;
+  owedIasset: bigint;
+  owedCollateralAsset: bigint;
+  redemptionFee: bigint;
+  mintingFee: bigint;
+};
+
+export type StableswapOrderInfo = {
+  order: ParsedOutput<StableswapOrderDatum>;
+  orderType: 'MINTING' | 'REDEEMING';
+  swapInfo: StableswapInfo;
+};
+
+/**
+ * This is an approximation of the amount of lovelace that will be needed to pay for the output.
+ */
+export function estimateMinOrderOutputLovelaces(
+  lucid: LucidEvolution,
+  orderDatum: StableswapOrderDatum,
+  /**
+   * Including execution fee as well.
+   */
+  orderAssets: Assets,
+): bigint {
+  const expectedOutputLovelaces = estimateUtxoMinLovelace(
+    lucid.config().protocolParameters!,
+    addressToBech32(orderDatum.destination, lucid.config().network!),
+    orderAssets,
+    {
+      kind: 'inline',
+      value: createDestinationDatum(orderDatum.destinationInlineDatum ?? null, {
+        txHash:
+          '0000000000000000000000000000000000000000000000000000000000000000',
+        outputIndex: 0,
+      }),
+    },
+  );
+
+  const roundedExpectedOutputLovelaces =
+    (expectedOutputLovelaces / 1_000_000n + 1n) * 1_000_000n;
+
+  return roundedExpectedOutputLovelaces;
+}
+
+type OrderTypeError = 'VALUE_ERROR';
+
+/**
+ * Determine the PSM order type.
+ */
+export function psmOrderType(
+  order: ParsedOutput<StableswapOrderDatum>,
+  sysParams: SystemParams,
+):
+  | { type: 'MINTING'; suppliedCollateral: bigint }
+  | { type: 'REDEEMING'; suppliedIassets: bigint }
+  | { type: 'ERROR'; errorTag: OrderTypeError; reason: string } {
+  const iassetAc = {
+    currencySymbol: fromHex(
+      sysParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: order.datum.iasset,
+  };
+
+  const suppliedIasset = assetClassValueOf(order.utxo.assets, iassetAc);
+  const suppliedCollateralAsset = assetClassValueOf(
+    order.utxo.assets,
+    order.datum.collateralAsset,
+  );
+
+  if (
+    (suppliedIasset != 0n && suppliedCollateralAsset != 0n) ||
+    (suppliedIasset == 0n && suppliedCollateralAsset == 0n)
+  ) {
+    return {
+      type: 'ERROR',
+      errorTag: 'VALUE_ERROR',
+      reason: 'An order must supply either iAsset or collateral asset',
+    };
+  }
+
+  const isMinting = suppliedCollateralAsset > 0n;
+
+  return isMinting
+    ? { type: 'MINTING', suppliedCollateral: suppliedCollateralAsset }
+    : { type: 'REDEEMING', suppliedIassets: suppliedIasset };
+}
+
+type SummaryError =
+  | OrderTypeError
+  | 'ASSET_MISMATCH'
+  | 'EXECUTION_FEE'
+  | 'MAX_FEE'
+  | 'INSUFFICIENT_LOVELACES';
+
+type SummaryResult =
+  | { _tag: 'SUCCESS'; result: StableswapOrderInfo }
+  | { _tag: 'ERROR'; errorTag: SummaryError; description: string };
+
+/**
+ * Summarise the order. Validate all the necessary constraints
+ * for this order to be processed.
+ */
+export function summariseOrder(
+  lucid: LucidEvolution,
+  order: ParsedOutput<StableswapOrderDatum>,
+  psmPool: ParsedOutput<StableswapPoolContent>,
+  sysParams: SystemParams,
+  psmProcessingConfig?: PSMProcessingConfig,
+): SummaryResult {
+  const config = {
+    ...defaultPSMProcessingConfig,
+    ...psmProcessingConfig,
+  } satisfies PSMProcessingConfig;
+
+  const orderType = psmOrderType(order, sysParams);
+
+  if (orderType.type === 'ERROR') {
+    return {
+      _tag: 'ERROR',
+      errorTag: orderType.errorTag,
+      description: orderType.reason,
+    };
+  }
+
+  if (
+    toHex(order.datum.iasset) !== toHex(psmPool.datum.iasset) ||
+    toHex(order.datum.collateralAsset.currencySymbol) !==
+      toHex(psmPool.datum.collateralAsset.currencySymbol) ||
+    toHex(order.datum.collateralAsset.tokenName) !==
+      toHex(psmPool.datum.collateralAsset.tokenName)
+  ) {
+    return {
+      _tag: 'ERROR',
+      errorTag: 'ASSET_MISMATCH',
+      description: 'Order - PSM assets mismatch',
+    };
+  }
+
+  const isOneToOne =
+    psmPool.datum.collateralToIassetRatio.numerator ===
+    psmPool.datum.collateralToIassetRatio.denominator;
+
+  // TODO: check that the order has enough funds.
+  if (
+    config.enforceMaxExecutionFeeConstraint &&
+    order.datum.maxExecutionFee < BASE_MAX_EXECUTION_FEE
+  ) {
+    return {
+      _tag: 'ERROR',
+      errorTag: 'EXECUTION_FEE',
+      description: `Max execution fee is too low. Minimum: ${BASE_MAX_EXECUTION_FEE}`,
+    };
+  }
+
+  if (
+    config.enforceMinLovelaceConstraint &&
+    lovelacesAmt(order.utxo.assets) <
+      estimateMinOrderOutputLovelaces(lucid, order.datum, order.utxo.assets) +
+        order.datum.maxExecutionFee
+  ) {
+    return {
+      _tag: 'ERROR',
+      errorTag: 'INSUFFICIENT_LOVELACES',
+      description:
+        'Order has insufficient lovelaces to cover execution fee and order output.',
+    };
+  }
+
+  if (orderType.type === 'MINTING') {
+    const suppliedCollateralAsset = orderType.suppliedCollateral;
+
+    if (
+      rationalToFloat(order.datum.maxFeeRatio) <
+      rationalToFloat(psmPool.datum.mintingFeeRatio)
+    ) {
+      return {
+        _tag: 'ERROR',
+        errorTag: 'MAX_FEE',
+        description: 'Max fee ratio not satisfied',
+      };
+    }
+
+    // Mint order with one to one ratio case.
+    if (isOneToOne) {
+      const fee = calculateFeeFromRatio(
+        psmPool.datum.mintingFeeRatio,
+        suppliedCollateralAsset,
+      );
+
+      return {
+        _tag: 'SUCCESS',
+        result: {
+          order: order,
+          orderType: 'MINTING',
+          swapInfo: {
+            suppliedCollateralAsset: suppliedCollateralAsset,
+            suppliedIasset: 0n,
+            owedCollateralAsset: 0n,
+            owedIasset: suppliedCollateralAsset - fee,
+            mintingFee: fee,
+            redemptionFee: 0n,
+          },
+        },
+      };
+      // Mint order with any ratio case.
+    } else {
+      const iAssetConversion = rationalFloor(
+        rationalDiv(
+          rationalFromInt(suppliedCollateralAsset),
+          psmPool.datum.collateralToIassetRatio,
+        ),
+      );
+
+      const attemptedNormalizedCollateral = rationalFloor(
+        rationalMul(
+          rationalFromInt(iAssetConversion),
+          psmPool.datum.collateralToIassetRatio,
+        ),
+      );
+
+      const normalizedCollateralSupplied =
+        rationalFloor(
+          rationalDiv(
+            rationalFromInt(attemptedNormalizedCollateral),
+            psmPool.datum.collateralToIassetRatio,
+          ),
+        ) != iAssetConversion
+          ? suppliedCollateralAsset
+          : attemptedNormalizedCollateral;
+
+      const fee = calculateFeeFromRatio(
+        psmPool.datum.mintingFeeRatio,
+        iAssetConversion,
+      );
+
+      return {
+        _tag: 'SUCCESS',
+        result: {
+          order: order,
+          orderType: 'MINTING',
+          swapInfo: {
+            suppliedCollateralAsset: normalizedCollateralSupplied,
+            suppliedIasset: 0n,
+            owedIasset: iAssetConversion - fee,
+            owedCollateralAsset: 0n,
+            mintingFee: fee,
+            redemptionFee: 0n,
+          },
+        },
+      };
+    }
+    // Redeem order case
+  } else {
+    const suppliedIasset = orderType.suppliedIassets;
+
+    if (
+      rationalToFloat(order.datum.maxFeeRatio) <
+      rationalToFloat(psmPool.datum.redemptionFeeRatio)
+    ) {
+      return {
+        _tag: 'ERROR',
+        errorTag: 'MAX_FEE',
+        description: 'Max fee ratio not satisfied',
+      };
+    }
+
+    const fee = calculateFeeFromRatio(
+      psmPool.datum.redemptionFeeRatio,
+      suppliedIasset,
+    );
+
+    const effectiveSuppliedIasset = suppliedIasset - fee;
+
+    // Redeem order with one to one ratio case
+    if (isOneToOne) {
+      return {
+        _tag: 'SUCCESS',
+        result: {
+          order: order,
+          orderType: 'REDEEMING',
+          swapInfo: {
+            suppliedIasset: effectiveSuppliedIasset,
+            suppliedCollateralAsset: 0n,
+            owedCollateralAsset: effectiveSuppliedIasset,
+            owedIasset: 0n,
+            redemptionFee: fee,
+            mintingFee: 0n,
+          },
+        },
+      };
+      // Redeem order with any ratio case
+    } else {
+      const collateralConversion = rationalFloor(
+        rationalMul(
+          rationalFromInt(effectiveSuppliedIasset),
+          psmPool.datum.collateralToIassetRatio,
+        ),
+      );
+
+      const attemptedNormalizedEffectiveIasset = rationalFloor(
+        rationalDiv(
+          rationalFromInt(collateralConversion),
+          psmPool.datum.collateralToIassetRatio,
+        ),
+      );
+
+      const normalizedEffectiveIasset =
+        rationalFloor(
+          rationalMul(
+            rationalFromInt(attemptedNormalizedEffectiveIasset),
+            psmPool.datum.collateralToIassetRatio,
+          ),
+        ) != collateralConversion
+          ? effectiveSuppliedIasset
+          : attemptedNormalizedEffectiveIasset;
+
+      return {
+        _tag: 'SUCCESS',
+        result: {
+          order: order,
+          orderType: 'REDEEMING',
+          swapInfo: {
+            suppliedIasset: normalizedEffectiveIasset,
+            suppliedCollateralAsset: 0n,
+            owedCollateralAsset: rationalFloor(
+              rationalMul(
+                rationalFromInt(effectiveSuppliedIasset),
+                psmPool.datum.collateralToIassetRatio,
+              ),
+            ),
+            owedIasset: 0n,
+            redemptionFee: fee,
+            mintingFee: 0n,
+          },
+        },
+      };
+    }
+  }
+}
+
+/**
+ * Pick only orders that are valid, belong to the PSM pool,
+ * and can be processed based on available liquidity.
+ */
+export function pickValidSatisfiableOrders(
+  lucid: LucidEvolution,
+  orders: ParsedOutput<StableswapOrderDatum>[],
+  pool: ParsedOutput<StableswapPoolContent>,
+  sysParams: SystemParams,
+  psmProcessingConfig?: PSMProcessingConfig,
+): ParsedOutput<StableswapOrderDatum>[] {
+  const psmAvailableLiq = assetClassValueOf(
+    pool.utxo.assets,
+    pool.datum.collateralAsset,
+  );
+
+  const validOrders = orders.flatMap((order) => {
+    try {
+      const res = summariseOrder(
+        lucid,
+        order,
+        pool,
+        sysParams,
+        psmProcessingConfig,
+      );
+      return res._tag === 'SUCCESS' ? [res.result] : [];
+    } catch (_) {
+      return [];
+    }
+  });
+
+  const { left: mintingOrders, right: redeemingOrdersSortedDesc } = F.pipe(
+    validOrders,
+    A.partition((o) => o.orderType === 'REDEEMING'),
+    ({ left, right }) => ({
+      left,
+      // Sort the redeeming orders descending.
+      right: F.pipe(
+        right,
+        A.sort(
+          Ord.contramap(
+            (o: StableswapOrderInfo) => o.swapInfo.owedCollateralAsset,
+          )(Ord.reverse(BigIntOrd)),
+        ),
+      ),
+    }),
+  );
+
+  const totalCollateralDiff = F.pipe(
+    validOrders,
+    A.reduce<StableswapOrderInfo, bigint>(
+      0n,
+      (acc, order) =>
+        acc +
+        order.swapInfo.suppliedCollateralAsset -
+        order.swapInfo.owedCollateralAsset,
+    ),
+  );
+
+  // When there's enough liquidity for processing all the orders,
+  // no need for addtional filtering.
+  if (psmAvailableLiq + totalCollateralDiff >= 0n) {
+    return validOrders.map((o) => o.order);
+  }
+
+  const collateralFromMinting = F.pipe(
+    mintingOrders,
+    A.reduce(0n, (acc, o) => acc + o.swapInfo.suppliedCollateralAsset),
+  );
+
+  // Take the redeeming orders from largest until there's enough liquidity.
+  const { selected } = F.pipe(
+    redeemingOrdersSortedDesc,
+    A.reduce(
+      {
+        intermediateCollateralAmt: psmAvailableLiq + collateralFromMinting,
+        selected: [] as StableswapOrderInfo[],
+      },
+      ({ intermediateCollateralAmt, selected }, order) =>
+        intermediateCollateralAmt >= order.swapInfo.owedCollateralAsset
+          ? {
+              intermediateCollateralAmt:
+                intermediateCollateralAmt - order.swapInfo.owedCollateralAsset,
+              selected: [...selected, order],
+            }
+          : { intermediateCollateralAmt, selected },
+    ),
+  );
+
+  return [...mintingOrders, ...selected].map((o) => o.order);
+}