@indigo-labs/indigo-sdk 0.4.3 → 0.5.0

package/{tests/queries/stability-pool-queries.ts → src/contracts/stability-pool/queries.ts}

@@ -1,10 +1,10 @@
-import { fromText, LucidEvolution, toHex, UTxO } from '@lucid-evolution/lucid';
+import { LucidEvolution, toHex, UTxO } from '@lucid-evolution/lucid';
 import {
-  fromSystemParamsAsset,
+  assetClassToUnit,
   matchSingle,
-  mkStabilityPoolAddr,
-  SystemParams,
-} from '../../src';
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { option as O, array as A, function as F } from 'fp-ts';
+import { fromSystemParamsAsset, SystemParams } from '../../types/system-params';
 import {
   AccountContent,
   parseAccountDatum,
@@ -12,14 +12,16 @@ import {
   parseStabilityPoolDatum,
   SnapshotEpochToScaleToSumContent,
   StabilityPoolContent,
-} from '../../src/contracts/stability-pool/types-new';
-import { assetClassToUnit } from '@3rd-eye-labs/cardano-offchain-common';
-import { option as O, array as A, function as F } from 'fp-ts';
+} from './types-new';
+import { mkStabilityPoolAddr } from './helpers';
 
 export async function findStabilityPool(
   lucid: LucidEvolution,
   sysParams: SystemParams,
-  asset: string,
+  /**
+   * For conversion from hex use the `fromHex` function from lucid-evolution.
+   */
+  iassetName: Uint8Array<ArrayBufferLike>,
 ): Promise<{ utxo: UTxO; datum: StabilityPoolContent }> {
   // We need to consider both with staking credential and without.
   const spUtxos = await lucid.utxosAtWithUnit(
@@ -36,7 +38,7 @@ export async function findStabilityPool(
           O.fromNullable(utxo.datum),
           O.flatMap(parseStabilityPoolDatum),
           O.flatMap((datum) => {
-            if (toHex(datum.iasset) == fromText(asset)) {
+            if (toHex(datum.iasset) == toHex(iassetName)) {
               return O.some({ utxo, datum: datum });
             } else {
               return O.none;
@@ -57,7 +59,10 @@ export async function findStabilityPoolAccount(
   lucid: LucidEvolution,
   sysParams: SystemParams,
   owner: string,
-  asset: string,
+  /**
+   * For conversion from hex use the `fromHex` function from lucid-evolution.
+   */
+  iassetName: Uint8Array<ArrayBufferLike>,
 ): Promise<{ utxo: UTxO; datum: AccountContent }> {
   // We need to consider both with staking credential and without.
   const spUtxos = await lucid.utxosAt({
@@ -73,7 +78,7 @@ export async function findStabilityPoolAccount(
           O.flatMap(parseAccountDatum),
           O.flatMap((datum) => {
             if (
-              toHex(datum.iasset) == fromText(asset) &&
+              toHex(datum.iasset) == toHex(iassetName) &&
               toHex(datum.owner) == owner
             ) {
               return O.some({ utxo, datum: datum });
@@ -93,7 +98,10 @@ export async function findStabilityPoolAccount(
 export async function findE2s2sSnapshots(
   lucid: LucidEvolution,
   sysParams: SystemParams,
-  asset: string,
+  /**
+   * For conversion from hex use the `fromHex` function from lucid-evolution.
+   */
+  iassetName: Uint8Array<ArrayBufferLike>,
 ): Promise<{ utxo: UTxO; datum: SnapshotEpochToScaleToSumContent }[]> {
   // No need to query the ones without stake cred, e2s2s will always have stake cred based on script params.
   const spUtxos = await lucid.utxosAtWithUnit(
@@ -111,7 +119,7 @@ export async function findE2s2sSnapshots(
         O.fromNullable(utxo.datum),
         O.flatMap(parseSnapshotEpochToScaleToSumDatum),
         O.flatMap((datum) => {
-          if (toHex(datum.iasset) == fromText(asset)) {
+          if (toHex(datum.iasset) == toHex(iassetName)) {
             return O.some({ utxo, datum: datum });
           } else {
             return O.none;

package/src/contracts/stability-pool/transactions.ts

@@ -8,7 +8,6 @@ import {
   toHex,
   addAssets,
   OutRef,
-  slotToUnixTime,
   credentialToAddress,
 } from '@lucid-evolution/lucid';
 import {
@@ -267,11 +266,9 @@ async function processSpRequestAuxiliary(
   allE2s2sSnapshotOrefs: OutRef[],
   sysParams: SystemParams,
   lucid: LucidEvolution,
-  currentSlot: number,
   txFee: bigint,
 ): Promise<TxBuilder> {
-  const network = lucid.config().network!;
-  const currentTime = BigInt(slotToUnixTime(network, currentSlot));
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
 
   const stabilityPoolScriptRef = matchSingle(
     await lucid.utxosByOutRef([
@@ -292,7 +289,7 @@ async function processSpRequestAuxiliary(
 
   const baseRefInputs = [iAssetUtxo, stabilityPoolScriptRef];
 
-  const validFrom = slotToUnixTime(network, currentSlot - 1);
+  const validFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
   const tx = lucid
     .newTx()
     .validFrom(validFrom)
@@ -770,7 +767,6 @@ export async function processSpRequest(
   allE2s2sSnapshotOrefs: OutRef[],
   sysParams: SystemParams,
   lucid: LucidEvolution,
-  currentSlot: number,
 ): Promise<TxBuilder> {
   const draftTx = processSpRequestAuxiliary(
     stabilityPoolUtxo,
@@ -779,7 +775,6 @@ export async function processSpRequest(
     allE2s2sSnapshotOrefs,
     sysParams,
     lucid,
-    currentSlot,
     // Placeholder transation fee
     1n,
   );
@@ -793,7 +788,6 @@ export async function processSpRequest(
     allE2s2sSnapshotOrefs,
     sysParams,
     lucid,
-    currentSlot,
     fee,
   );
 }

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);
+}