@indigo-labs/indigo-sdk 0.4.4 → 0.5.0

package/src/contracts/stableswap/helpers.ts

@@ -1,9 +1,41 @@
 import { fromHex, fromText, OutRef } from '@lucid-evolution/lucid';
-import { serialiseStableswapOutputDatum } from './types-new';
+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 { assetClassValueOf } 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';
 
 export const BASE_MAX_EXECUTION_FEE = 1_620_000n;
 
+export type OrderProcessConfig = {
+  /**
+   * Whether to ignore that an order has max execution fee set lower
+   * than the threshold (i.e. the processor might be paying the remaining cardano tx fee).
+   *
+   * The default should be `false`. In case, owner wants to process
+   * such order himself, he can ignore the constraint.
+   */
+  ignoreMaxExecutionFeeConstraint: boolean;
+};
+
+export const defaultOrderProcessingConfig: OrderProcessConfig = {
+  ignoreMaxExecutionFeeConstraint: false,
+};
+
 export function createDestinationDatum(
   datum: Data.Data | null,
   outRef: OutRef,
@@ -20,3 +52,339 @@ 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;
+};
+
+/**
+ * Determine the PSM order type.
+ */
+export function psmOrderType(
+  order: ParsedOutput<StableswapOrderDatum>,
+  sysParams: SystemParams,
+):
+  | { type: 'MINTING'; suppliedCollateral: bigint }
+  | { type: 'REDEEMING'; suppliedIassets: bigint }
+  | { type: 'ERROR'; 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',
+      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 SummaryResult =
+  | { _tag: 'SUCCESS'; result: StableswapOrderInfo }
+  | { _tag: 'ERROR'; reason: string };
+
+/**
+ * Summarise the order in detail
+ */
+export function summariseOrder(
+  order: ParsedOutput<StableswapOrderDatum>,
+  psmPool: ParsedOutput<StableswapPoolContent>,
+  sysParams: SystemParams,
+  orderProcessingConfig: OrderProcessConfig,
+): SummaryResult {
+  const orderType = psmOrderType(order, sysParams);
+
+  if (orderType.type === 'ERROR') {
+    return { _tag: 'ERROR', reason: orderType.reason };
+  }
+
+  const isOneToOne =
+    psmPool.datum.collateralToIassetRatio.numerator ===
+    psmPool.datum.collateralToIassetRatio.denominator;
+
+  if (
+    !orderProcessingConfig.ignoreMaxExecutionFeeConstraint &&
+    order.datum.maxExecutionFee < BASE_MAX_EXECUTION_FEE
+  ) {
+    return {
+      _tag: 'ERROR',
+      reason: `Max execution fee is too low. Minimum: ${BASE_MAX_EXECUTION_FEE}`,
+    };
+  }
+
+  if (orderType.type === 'MINTING') {
+    const suppliedCollateralAsset = orderType.suppliedCollateral;
+
+    if (
+      rationalToFloat(order.datum.maxFeeRatio) <
+      rationalToFloat(psmPool.datum.mintingFeeRatio)
+    ) {
+      return { _tag: 'ERROR', reason: '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', reason: '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 and can be processed based on available liquidity.
+ */
+export function pickValidSatisfiableOrders(
+  orders: ParsedOutput<StableswapOrderDatum>[],
+  pool: ParsedOutput<StableswapPoolContent>,
+  sysParams: SystemParams,
+  orderProcessingConfig: OrderProcessConfig,
+): ParsedOutput<StableswapOrderDatum>[] {
+  const psmAvailableLiq = assetClassValueOf(
+    pool.utxo.assets,
+    pool.datum.collateralAsset,
+  );
+
+  const validOrders = orders.flatMap((order) => {
+    try {
+      const res = summariseOrder(order, pool, sysParams, orderProcessingConfig);
+      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);
+}

package/src/contracts/stableswap/transactions.ts

@@ -11,7 +11,6 @@ import {
   sortUTxOs,
   toHex,
   TxBuilder,
-  UTxO,
 } from '@lucid-evolution/lucid';
 import {
   fromSystemParamsScriptRef,
@@ -42,34 +41,20 @@ import {
   serialiseStableswapPoolDatum,
   StableswapPoolContent,
 } from '../cdp/types-new';
-import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
 import { array as A, function as F } from 'fp-ts';
 import { isEmpty } from 'fp-ts/lib/Array';
-import { BASE_MAX_EXECUTION_FEE, createDestinationDatum } from './helpers';
+import {
+  BASE_MAX_EXECUTION_FEE,
+  createDestinationDatum,
+  defaultOrderProcessingConfig,
+  OrderProcessConfig,
+  StableswapInfo,
+  StableswapOrderInfo,
+  summariseOrder,
+} from './helpers';
 import * as Core from '@evolution-sdk/evolution';
 import { treasuryFeeTx } from '../treasury/transactions';
-import {
-  Rational,
-  rationalDiv,
-  rationalFloor,
-  rationalFromInt,
-  rationalMul,
-} from '../../types/rational';
-
-type StableswapInfo = {
-  suppliedCollateralAsset: bigint;
-  suppliedIasset: bigint;
-  owedCollateralAsset: bigint;
-  owedIasset: bigint;
-  mintingFee: bigint;
-  redemptionFee: bigint;
-};
-
-type StableswapOrderInfo = {
-  utxo: UTxO;
-  datum: StableswapOrderDatum;
-  swapInfo: StableswapInfo;
-};
+import { Rational } from '../../types/rational';
 
 export async function createStableswapOrder(
   iasset: string,
@@ -188,6 +173,7 @@ export async function batchProcessStableswapOrders(
   treasuryOref: OutRef,
   sysParams: SystemParams,
   lucid: LucidEvolution,
+  orderProcessingConfig: OrderProcessConfig = defaultOrderProcessingConfig,
 ): Promise<TxBuilder> {
   const stableswapScriptRefUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -269,159 +255,18 @@ export async function batchProcessStableswapOrders(
         throw new Error('Wrong batch of orders');
       }
 
-      const suppliedIasset = assetClassValueOf(orderUtxo.assets, iassetAc);
-      const suppliedCollateralAsset = assetClassValueOf(
-        orderUtxo.assets,
-        collateralAc,
+      const res = summariseOrder(
+        { utxo: orderUtxo, datum: orderDatum },
+        { utxo: stableswapPoolUtxo, datum: stableswapPoolDatum },
+        sysParams,
+        orderProcessingConfig,
       );
 
-      if (
-        (suppliedIasset != 0n && suppliedCollateralAsset != 0n) ||
-        (suppliedIasset == 0n && suppliedCollateralAsset == 0n)
-      ) {
-        throw new Error(
-          'An order must supply either iAsset or collateral asset',
-        );
+      if (res._tag === 'ERROR') {
+        throw new Error(res.reason);
       }
 
-      const isMinting = suppliedCollateralAsset > 0n;
-
-      const isOneToOne =
-        stableswapPoolDatum.collateralToIassetRatio.numerator ===
-        stableswapPoolDatum.collateralToIassetRatio.denominator;
-
-      if (isMinting) {
-        // Mint order with one to one ratio case.
-        if (isOneToOne) {
-          const fee = calculateFeeFromRatio(
-            stableswapPoolDatum.mintingFeeRatio,
-            suppliedCollateralAsset,
-          );
-
-          return {
-            utxo: orderUtxo,
-            datum: orderDatum,
-            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),
-              stableswapPoolDatum.collateralToIassetRatio,
-            ),
-          );
-
-          const attemptedNormalizedCollateral = rationalFloor(
-            rationalMul(
-              rationalFromInt(iAssetConversion),
-              stableswapPoolDatum.collateralToIassetRatio,
-            ),
-          );
-
-          const normalizedCollateralSupplied =
-            rationalFloor(
-              rationalDiv(
-                rationalFromInt(attemptedNormalizedCollateral),
-                stableswapPoolDatum.collateralToIassetRatio,
-              ),
-            ) != iAssetConversion
-              ? suppliedCollateralAsset
-              : attemptedNormalizedCollateral;
-
-          const fee = calculateFeeFromRatio(
-            stableswapPoolDatum.mintingFeeRatio,
-            iAssetConversion,
-          );
-
-          return {
-            utxo: orderUtxo,
-            datum: orderDatum,
-            swapInfo: {
-              suppliedCollateralAsset: normalizedCollateralSupplied,
-              suppliedIasset: 0n,
-              owedCollateralAsset: 0n,
-              owedIasset: iAssetConversion - fee,
-              mintingFee: fee,
-              redemptionFee: 0n,
-            },
-          };
-        }
-        // Redeem order case
-      } else {
-        const fee = calculateFeeFromRatio(
-          stableswapPoolDatum.redemptionFeeRatio,
-          suppliedIasset,
-        );
-
-        const effectiveSuppliedIasset = suppliedIasset - fee;
-
-        // Redeem order with one to one ratio case
-        if (isOneToOne) {
-          return {
-            utxo: orderUtxo,
-            datum: orderDatum,
-            swapInfo: {
-              suppliedCollateralAsset: 0n,
-              suppliedIasset: effectiveSuppliedIasset,
-              owedCollateralAsset: effectiveSuppliedIasset,
-              owedIasset: 0n,
-              mintingFee: 0n,
-              redemptionFee: fee,
-            },
-          };
-          // Redeem order with any ratio case
-        } else {
-          const collateralConversion = rationalFloor(
-            rationalMul(
-              rationalFromInt(effectiveSuppliedIasset),
-              stableswapPoolDatum.collateralToIassetRatio,
-            ),
-          );
-
-          const attemptedNormalizedEffectiveIasset = rationalFloor(
-            rationalDiv(
-              rationalFromInt(collateralConversion),
-              stableswapPoolDatum.collateralToIassetRatio,
-            ),
-          );
-
-          const normalizedEffectiveIasset =
-            rationalFloor(
-              rationalMul(
-                rationalFromInt(attemptedNormalizedEffectiveIasset),
-                stableswapPoolDatum.collateralToIassetRatio,
-              ),
-            ) != collateralConversion
-              ? effectiveSuppliedIasset
-              : attemptedNormalizedEffectiveIasset;
-
-          return {
-            utxo: orderUtxo,
-            datum: orderDatum,
-            swapInfo: {
-              suppliedCollateralAsset: 0n,
-              suppliedIasset: normalizedEffectiveIasset,
-              owedCollateralAsset: rationalFloor(
-                rationalMul(
-                  rationalFromInt(effectiveSuppliedIasset),
-                  stableswapPoolDatum.collateralToIassetRatio,
-                ),
-              ),
-              owedIasset: 0n,
-              mintingFee: 0n,
-              redemptionFee: fee,
-            },
-          };
-        }
-      }
+      return res.result;
     },
   );
 
@@ -448,7 +293,7 @@ export async function batchProcessStableswapOrders(
           owedIasset: acc.owedIasset + orderInfo.swapInfo.owedIasset,
           mintingFee: acc.mintingFee + orderInfo.swapInfo.mintingFee,
           redemptionFee: acc.redemptionFee + orderInfo.swapInfo.redemptionFee,
-        };
+        } satisfies StableswapInfo;
       },
     ),
   );
@@ -456,6 +301,15 @@ export async function batchProcessStableswapOrders(
   const collateralAmtChangePool =
     totalSwapInfo.suppliedCollateralAsset - totalSwapInfo.owedCollateralAsset;
 
+  const newPsmPoolValue = addAssets(
+    stableswapPoolUtxo.assets,
+    mkAssetsOf(collateralAc, collateralAmtChangePool),
+  );
+
+  if (assetClassValueOf(newPsmPoolValue, collateralAc) < 0n) {
+    throw new Error('Cannot batch more than liquidity allows');
+  }
+
   const amountToMint =
     totalSwapInfo.owedIasset -
     totalSwapInfo.suppliedIasset +
@@ -486,12 +340,7 @@ export async function batchProcessStableswapOrders(
         kind: 'inline',
         value: serialiseStableswapPoolDatum(stableswapPoolDatum),
       },
-      collateralAmtChangePool != 0n
-        ? addAssets(
-            stableswapPoolUtxo.assets,
-            mkAssetsOf(collateralAc, collateralAmtChangePool),
-          )
-        : stableswapPoolUtxo.assets,
+      newPsmPoolValue,
     )
     // This has to be added as otherwise there is the following error:
     // TxBuilderError: { Complete: RedeemerBuilder: Coin selection had to be updated
@@ -509,8 +358,8 @@ export async function batchProcessStableswapOrders(
     A.reduce<StableswapOrderInfo, TxBuilder>(tx, (acc, orderInfo) => {
       return acc
         .collectFrom(
-          [orderInfo.utxo],
-          isSameOutRef(orderInfo.utxo, mainOrderUtxo)
+          [orderInfo.order.utxo],
+          isSameOutRef(orderInfo.order.utxo, mainOrderUtxo)
             ? serialiseStableswapOrderRedeemer('BatchProcessStableswapOrders')
             : {
                 kind: 'selected',
@@ -522,26 +371,29 @@ export async function batchProcessStableswapOrders(
                     },
                   });
                 },
-                inputs: [orderInfo.utxo, mainOrderUtxo],
+                inputs: [orderInfo.order.utxo, mainOrderUtxo],
               },
         )
         .pay.ToAddressWithData(
-          addressToBech32(orderInfo.datum.destination, lucid.config().network!),
+          addressToBech32(
+            orderInfo.order.datum.destination,
+            lucid.config().network!,
+          ),
           {
             kind: 'inline',
             value: createDestinationDatum(
-              orderInfo.datum.destinationInlineDatum ?? null,
-              orderInfo.utxo,
+              orderInfo.order.datum.destinationInlineDatum ?? null,
+              orderInfo.order.utxo,
             ),
           },
           addAssets(
-            // Currently, we always take the max execution fee from the order utxo.
+            // NOTICE: Currently, we always take the max execution fee from the order utxo.
             // This can be improved so that we take the actual execution fee.
             mkLovelacesOf(
-              lovelacesAmt(orderInfo.utxo.assets) -
-                orderInfo.datum.maxExecutionFee,
+              lovelacesAmt(orderInfo.order.utxo.assets) -
+                orderInfo.order.datum.maxExecutionFee,
             ),
-            orderInfo.swapInfo.owedIasset > 0
+            orderInfo.orderType === 'MINTING'
               ? mkAssetsOf(iassetAc, orderInfo.swapInfo.owedIasset)
               : mkAssetsOf(
                   collateralAc,