@indigo-labs/indigo-sdk 0.5.5 → 0.5.6

package/src/contracts/stableswap/helpers.ts

@@ -1,507 +0,0 @@
-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,
-): string {
-  if (!datum) {
-    return serialiseStableswapOutputDatum([
-      fromHex(fromText('IndigoStableswap')),
-      {
-        txHash: fromHex(outRef.txHash),
-        outputIndex: BigInt(outRef.outputIndex),
-      },
-    ]);
-  }
-
-  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);
-}

package/src/contracts/stableswap/scripts.ts

@@ -1,37 +0,0 @@
-import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
-import { castStableswapParams, StableswapParams } from './types';
-import {
-  fromSystemParamsAssetLucid,
-  StableswapParamsSP,
-} from '../../types/system-params';
-import { _stableswapValidator } from '../../validators/stableswap-validator';
-
-export const mkStableswapValidator = (
-  params: StableswapParams,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_stableswapValidator.cborHex, [
-      castStableswapParams(params),
-    ]),
-  };
-};
-
-export const mkStableswapValidatorFromSP = (
-  params: StableswapParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_stableswapValidator.cborHex, [
-      castStableswapParams({
-        iassetSymbol: params.iassetSymbol.unCurrencySymbol,
-        cdpToken: fromSystemParamsAssetLucid(params.cdpToken),
-        versionRecordToken: fromSystemParamsAssetLucid(
-          params.versionRecordToken,
-        ),
-        cdpValHash: params.cdpValHash,
-        treasuryValHash: params.treasuryValHash,
-      }),
-    ]),
-  };
-};