@indigo-labs/indigo-sdk 0.5.5 → 0.5.6

package/src/contracts/rob/helpers.ts

@@ -1,666 +0,0 @@
-import {
-  addAssets,
-  Assets,
-  fromHex,
-  toHex,
-  TxBuilder,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import {
-  RobDatum,
-  RobOrderType,
-  parseRobDatumOrThrow,
-  serialiseRobDatum,
-  serialiseRobRedeemer,
-} from './types-new';
-import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
-import {
-  BigIntOrd,
-  fromDecimal,
-  sum,
-  zeroNegatives,
-} from '../../utils/bigint-utils';
-import {
-  readonlyArray as RA,
-  array as A,
-  function as F,
-  option as O,
-  ord as Ord,
-} from 'fp-ts';
-import { SystemParams } from '../../types/system-params';
-import { match, P } from 'ts-pattern';
-import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
-import {
-  adaAssetClass,
-  AssetClass,
-  assetClassValueOf,
-  isSameAssetClass,
-  lovelacesAmt,
-  mkAssetsOf,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import {
-  Rational,
-  rationalFloor,
-  rationalFromInt,
-  rationalMul,
-  rationalToFloat,
-} from '../../types/rational';
-import { insertSorted, shuffle } from '../../utils/array-utils';
-import { iassetValueOfCollateral } from '../cdp/helpers';
-import { OracleIdx } from '../price-oracle/types-new';
-import Decimal from 'decimal.js';
-
-export const MIN_ROB_COLLATERAL_AMT = 3_000_000n;
-
-/**
- * The maximum of redemptions for a Tx that is doing only sell order redemptions.
- * Based on the benchmarks.
- */
-export const MAX_SELL_ROB_REDEMPTIONS_COUNT = 18;
-/**
- * The maximum of redemptions for a Tx that is doing only buy order redemptions.
- * Based on the benchmarks.
- */
-export const MAX_BUY_ROB_REDEMPTIONS_COUNT = 20;
-
-/**
- * Helper for ROB redemptions. A redeemer is selling iAssets against
- * a buy order, i.e. buying a collateral asset.
- * The return is the amount of collateral asset he buys.
- */
-export function calculatePurchaseAmtWhenRobBuyOrder(
-  sellIassetAmt: bigint,
-  redemptionReimbursementRatio: Rational,
-  price: Rational,
-): bigint {
-  const reimbursementIAsset = calculateFeeFromRatio(
-    redemptionReimbursementRatio,
-    sellIassetAmt,
-  );
-
-  const collateralForRedemption = rationalFloor(
-    rationalMul(rationalFromInt(sellIassetAmt - reimbursementIAsset), price),
-  );
-
-  return collateralForRedemption;
-}
-
-/**
- * A redeemer is purchasing given collateral amount against buy order.
- * Calculate what is the amount of iAsset the user sells/spends.
- */
-export function calculateSpendAmtWhenRobBuyOrder(
-  purchaseCollateralAmt: bigint,
-  redemptionReimbursementRatio: Rational,
-  price: Rational,
-): bigint {
-  const priceDecimal = Decimal(price.numerator).div(price.denominator);
-  const reimbRatio = Decimal(redemptionReimbursementRatio.numerator).div(
-    redemptionReimbursementRatio.denominator,
-  );
-
-  // TODO: make corrections here in case we can be ceiling this number instead.
-  // We want to be flooring here so that we don't go over the collateral to spend.
-  // Flooring multiple times is necessary here otherwise we could go over the collateral available.
-  // iassets = floor(collateral / price) / floor(1 - reimbursement fee)
-  return fromDecimal(
-    Decimal(purchaseCollateralAmt)
-      .div(priceDecimal)
-      .floor()
-      .div(Decimal(1).minus(reimbRatio))
-      .floor(),
-  );
-}
-
-/**
- * Helper for ROB redemptions. A redeemer is selling collateral against
- * a sell order, i.e. buying iassets.
- * The return is the amount of iassets he buys.
- */
-export function calculatePurchaseAmtWhenRobSellOrder(
-  sellCollateralAmt: bigint,
-  redemptionReimbursementRatio: Rational,
-  price: Rational,
-): bigint {
-  const reimbursementCollateral = calculateFeeFromRatio(
-    redemptionReimbursementRatio,
-    sellCollateralAmt,
-  );
-
-  const redeemedIAssetAmt = iassetValueOfCollateral(
-    sellCollateralAmt - reimbursementCollateral,
-    price,
-  );
-
-  return redeemedIAssetAmt;
-}
-
-/**
- * A redeemer is purchasing given iasset amount against sell order.
- * Calculate what is the amount of collateral the user sells/spends.
- */
-export function calculateSpendAmtWhenRobSellOrder(
-  purchaseIassetAmt: bigint,
-  redemptionReimbursementRatio: Rational,
-  price: Rational,
-): bigint {
-  const priceDecimal = Decimal(price.numerator).div(price.denominator);
-  const reimbRatio = Decimal(redemptionReimbursementRatio.numerator).div(
-    redemptionReimbursementRatio.denominator,
-  );
-
-  // collateral = floor(iasset * price) / floor(1 - reimbursement fee)
-  return fromDecimal(
-    Decimal(purchaseIassetAmt)
-      .mul(priceDecimal)
-      .floor()
-      .div(Decimal(1).minus(reimbRatio))
-      .floor(),
-  );
-}
-
-/**
- * The amount of collateral asset available in the ROB when buy order. In case of ADA, take
- * into account the min UTXO collateral.
- */
-export function robCollateralAmtToSpend(
-  robAssets: Assets,
-  robOrderType: RobOrderType,
-): bigint {
-  return match(robOrderType)
-    .returnType<bigint>()
-    .with({ BuyIAssetOrder: P.select() }, (content) => {
-      if (isSameAssetClass(adaAssetClass, content.collateralAsset)) {
-        return zeroNegatives(lovelacesAmt(robAssets) - MIN_ROB_COLLATERAL_AMT);
-      } else {
-        return assetClassValueOf(robAssets, content.collateralAsset);
-      }
-    })
-    .otherwise(() => {
-      throw new Error('Collateral to spend is relevant only for Buy orders.');
-    });
-}
-
-/**
- * The amount if iassets available in ROB when sell order.
- */
-export function robIAssetAmtToSpend(
-  robAssets: Assets,
-  robOrderType: RobOrderType,
-  /**
-   * This has to be assetclass having policyID of Indigo iAssets,
-   * and the asset name being the ROB datum iasset.
-   */
-  robIasset: AssetClass,
-): bigint {
-  return match(robOrderType)
-    .returnType<bigint>()
-    .with({ SellIAssetOrder: P.any }, (_) => {
-      return assetClassValueOf(robAssets, robIasset);
-    })
-    .otherwise(() => {
-      throw new Error('IAssets to spend is relevant only for Sell orders.');
-    });
-}
-
-/**
- * Amount to spend from the ROB universal for Buy and sell orders.
- */
-export function robAmtToSpend(
-  robAssets: Assets,
-  robOrderType: RobOrderType,
-  /**
-   * This has to be assetclass having policyID of Indigo iAssets,
-   * and the asset name being the ROB datum iasset.
-   */
-  robIasset: AssetClass,
-): bigint {
-  return match(robOrderType)
-    .with({ BuyIAssetOrder: P.any }, () =>
-      robCollateralAmtToSpend(robAssets, robOrderType),
-    )
-    .with({ SellIAssetOrder: P.any }, () =>
-      robIAssetAmtToSpend(robAssets, robOrderType, robIasset),
-    )
-    .exhaustive();
-}
-
-type FilledResult = { asset: AssetClass; filledAmt: bigint };
-
-/**
- * The assets that have filled the order and are able to be claimed.
- */
-export function robBuyOrderFilledAssets(
-  robAssets: Assets,
-  robOrderType: RobOrderType,
-  /**
-   * This has to be assetclass having policyID of Indigo iAssets,
-   * and the asset name being the ROB datum iasset.
-   */
-  robIasset: AssetClass,
-): FilledResult {
-  return match(robOrderType)
-    .returnType<FilledResult>()
-    .with({ BuyIAssetOrder: P.any }, () => {
-      return {
-        asset: robIasset,
-        filledAmt: assetClassValueOf(robAssets, robIasset),
-      };
-    })
-    .otherwise(() => {
-      throw new Error('Expected only buy order.');
-    });
-}
-
-/**
- * The assets that have filled the order and are able to be claimed.
- */
-export function robSellOrderFilledAssets(
-  robAssets: Assets,
-  robOrderType: RobOrderType,
-): FilledResult[] {
-  return match(robOrderType)
-    .returnType<FilledResult[]>()
-    .with({ SellIAssetOrder: P.select() }, (content) => {
-      return content.allowedCollateralAssets.map(([asset, _]) => {
-        return {
-          asset: asset,
-          filledAmt:
-            assetClassValueOf(robAssets, asset) -
-            (isSameAssetClass(asset, adaAssetClass)
-              ? MIN_ROB_COLLATERAL_AMT
-              : 0n),
-        } satisfies FilledResult;
-      });
-    })
-    .otherwise(() => {
-      throw new Error('Expected only sell order.');
-    });
-}
-
-export function robBuyOrderSummary(
-  robAssets: Assets,
-  robOrderType: RobOrderType,
-  oraclePrice: Rational,
-): {
-  /**
-   * The amount that can be spent from the ROB.
-   */
-  redeemableCollateral: bigint;
-  /**
-   * The amount paid to the ROB when everything redeemed.
-   */
-  payoutIAsset: bigint;
-} {
-  const redeemable = robCollateralAmtToSpend(robAssets, robOrderType);
-
-  // TODO: this is incorrect since it doesn't take into account the reimbursement ratio.
-  const payoutAmt = iassetValueOfCollateral(redeemable, oraclePrice);
-
-  return {
-    redeemableCollateral: redeemable,
-    payoutIAsset: payoutAmt,
-  };
-}
-
-/**
- * In case it's applied to a sell order instead, it will throw an error.
- */
-export function isBuyOrderFullyRedeemed(
-  robAssets: Assets,
-  robOrderType: RobOrderType,
-  oraclePrice: Rational,
-): boolean {
-  const summary = robBuyOrderSummary(robAssets, robOrderType, oraclePrice);
-
-  return summary.redeemableCollateral <= 0n || summary.payoutIAsset <= 0n;
-}
-
-/**
- * Use the limit prices to decide fully redeemed.
- */
-export function isFullyRedeemed(
-  robAssets: Assets,
-  robOrderType: RobOrderType,
-  /**
-   * This has to be assetclass having policyID of Indigo iAssets,
-   * and the asset name being the ROB datum iasset.
-   */
-  robIasset: AssetClass,
-): boolean {
-  return match(robOrderType)
-    .returnType<boolean>()
-    .with({ BuyIAssetOrder: P.select() }, (content) =>
-      isBuyOrderFullyRedeemed(robAssets, robOrderType, content.maxPrice),
-    )
-
-    .with({ SellIAssetOrder: P.select() }, (content) => {
-      const iassetToSpend = robIAssetAmtToSpend(
-        robAssets,
-        robOrderType,
-        robIasset,
-      );
-
-      const payoutAmts = content.allowedCollateralAssets.map((c) =>
-        rationalFloor(rationalMul(rationalFromInt(iassetToSpend), c[1])),
-      );
-
-      return (
-        iassetToSpend <= 0n ||
-        // When for every allowed collateral asset the payout would be 0
-        payoutAmts.every((amt) => amt <= 0n)
-      );
-    })
-    .exhaustive();
-}
-
-/**
- * Right now we allow multi redemptions when the collateral asset, iasset pair is the same.
- * The on-chain however should allow even other combinations.
- */
-export function buildRedemptionsTx(
-  /**
-   * The tuple represents the ROB UTXO and the amount to payout for a redemption. In case of buy order,
-   * it's denominated in iAssets, in case of sell order, it's denominated in collateral asset.
-   */
-  redemptions: [UTxO, bigint][],
-  iasset: Uint8Array<ArrayBufferLike>,
-  collateralAsset: AssetClass,
-  price: Rational,
-  redemptionReimbursementRatio: Rational,
-  sysParams: SystemParams,
-  tx: TxBuilder,
-  /**
-   * The number of Tx outputs before these new ones.
-   */
-  txOutputsBeforeCount: bigint,
-  collateralAssetRefInputIdx: bigint,
-  iassetRefInputIdx: bigint,
-  oracleIdx: OracleIdx,
-): TxBuilder {
-  return F.pipe(
-    redemptions,
-    A.reduceWithIndex<[UTxO, bigint], TxBuilder>(
-      tx,
-      (idx, acc, [robUtxo, payoutAmt]) => {
-        const robDatum = parseRobDatumOrThrow(getInlineDatumOrThrow(robUtxo));
-
-        if (toHex(robDatum.iasset) !== toHex(iasset)) {
-          throw new Error('Only same iAsset');
-        }
-
-        const [robOutputVal, sellOrderAllowedAssetsIdx] = match(
-          robDatum.orderType,
-        )
-          .returnType<[Assets, bigint]>()
-          .with({ BuyIAssetOrder: P.select() }, (content) => {
-            if (!isSameAssetClass(content.collateralAsset, collateralAsset)) {
-              throw new Error('Only same collateral asset');
-            }
-
-            const payoutIAssetAmt = payoutAmt;
-
-            const collateralForRedemption = calculatePurchaseAmtWhenRobBuyOrder(
-              payoutIAssetAmt,
-              redemptionReimbursementRatio,
-              price,
-            );
-
-            const resultVal = addAssets(
-              robUtxo.assets,
-              mkAssetsOf(collateralAsset, -collateralForRedemption),
-              mkAssetsOf(
-                {
-                  currencySymbol: fromHex(
-                    sysParams.robParams.iassetPolicyId.unCurrencySymbol,
-                  ),
-                  tokenName: robDatum.iasset,
-                },
-                payoutIAssetAmt,
-              ),
-            );
-
-            return [resultVal, 0n];
-          })
-          .with({ SellIAssetOrder: P.select() }, (content) => {
-            const allowedAssetIdx = F.pipe(
-              content.allowedCollateralAssets,
-              RA.findIndex(([asset, _]) =>
-                isSameAssetClass(asset, collateralAsset),
-              ),
-              O.getOrElse<number>(() => {
-                throw new Error("Doesn't allow required collateral asset.");
-              }),
-            );
-
-            const payoutCollateralAmt = payoutAmt;
-
-            const redeemedIAssetAmt = calculatePurchaseAmtWhenRobSellOrder(
-              payoutCollateralAmt,
-              redemptionReimbursementRatio,
-              price,
-            );
-
-            const resultVal = addAssets(
-              robUtxo.assets,
-              mkAssetsOf(collateralAsset, payoutCollateralAmt),
-              mkAssetsOf(
-                {
-                  currencySymbol: fromHex(
-                    sysParams.robParams.iassetPolicyId.unCurrencySymbol,
-                  ),
-                  tokenName: robDatum.iasset,
-                },
-                -redeemedIAssetAmt,
-              ),
-            );
-
-            return [resultVal, BigInt(allowedAssetIdx)];
-          })
-          .exhaustive();
-
-        if (lovelacesAmt(robOutputVal) < MIN_ROB_COLLATERAL_AMT) {
-          throw new Error(
-            'Redeeming more than available or selected ROB was incorrectly initialised.',
-          );
-        }
-
-        return acc
-          .collectFrom([robUtxo], {
-            kind: 'self',
-            makeRedeemer: (ownIdx) =>
-              serialiseRobRedeemer({
-                Redeem: {
-                  ownInputIdx: ownIdx,
-                  collateralAssetRefInputIdx: collateralAssetRefInputIdx,
-                  iassetRefInputIdx: iassetRefInputIdx,
-                  continuingOutputIdx: txOutputsBeforeCount + BigInt(idx),
-                  sellOrderAllowedAssetsIdx: sellOrderAllowedAssetsIdx,
-                  priceOracleIdx: oracleIdx,
-                },
-              }),
-          })
-          .pay.ToContract(
-            robUtxo.address,
-            {
-              kind: 'inline',
-              value: serialiseRobDatum({
-                ...robDatum,
-                robRefInput: {
-                  outputIndex: BigInt(robUtxo.outputIndex),
-                  txHash: fromHex(robUtxo.txHash),
-                },
-              }),
-            },
-            robOutputVal,
-          );
-      },
-    ),
-  );
-}
-
-/**
- * Given all available LRP UTXOs, calculate total available collateral that can be redeemed.
- * Taking into account incorrectly initialised LRPs (without base collateral) and max number of ROBs.
- */
-export function calculateTotalCollateralForRedemption(
-  iasset: Uint8Array<ArrayBufferLike>,
-  collateralAsset: AssetClass,
-  iassetPrice: Rational,
-  allRobs: [UTxO, RobDatum][],
-  /**
-   * How many LRPs can be redeemed in a single Tx.
-   */
-  maxRobsInTx: number,
-): bigint {
-  return F.pipe(
-    allRobs,
-    A.filterMap(([utxo, datum]) => {
-      const isCorrectOrder = match(datum.orderType)
-        .returnType<boolean>()
-        .with(
-          { BuyIAssetOrder: P.select() },
-          (content) =>
-            isSameAssetClass(content.collateralAsset, collateralAsset) &&
-            rationalToFloat(content.maxPrice) >= rationalToFloat(iassetPrice) &&
-            !isBuyOrderFullyRedeemed(utxo.assets, datum.orderType, iassetPrice),
-        )
-        .otherwise(() => false);
-
-      if (toHex(datum.iasset) !== toHex(iasset) || !isCorrectOrder) {
-        return O.none;
-      }
-
-      // We constrained in the logic above that the ROB is a buy order and is not yet fully redeemed.
-      const collateralToSpend = robCollateralAmtToSpend(
-        utxo.assets,
-        datum.orderType,
-      );
-
-      return O.some(collateralToSpend);
-    }),
-    // From largest to smallest
-    A.sort(Ord.reverse(BigIntOrd)),
-    // We can fit only this number of redemptions with CDP open into a single Tx.
-    A.takeLeft(maxRobsInTx),
-    sum,
-  );
-}
-
-/**
- * Pick random subset from all the ROBs (it does the necessary filtering) satisfying the target collateral to spend.
- * It's relevant for BUY orders only.
- */
-export function randomRobsSubsetSatisfyingTargetCollateral(
-  iasset: Uint8Array<ArrayBufferLike>,
-  collateralAsset: AssetClass,
-  targetCollateralToSpend: bigint,
-  iassetPrice: Rational,
-  allLrps: [UTxO, RobDatum][],
-  /**
-   * How many LRPs can be redeemed in a single Tx.
-   */
-  maxLrpsInTx: number,
-  randomiseFn: (arr: [UTxO, RobDatum][]) => [UTxO, RobDatum][] = shuffle,
-): [UTxO, RobDatum][] {
-  if (
-    targetCollateralToSpend <= 0n ||
-    iassetValueOfCollateral(targetCollateralToSpend, iassetPrice) <= 0n
-  ) {
-    throw new Error('Must redeem and payout more than 0.');
-  }
-
-  const shuffled = randomiseFn(
-    F.pipe(
-      allLrps,
-      A.filter(
-        ([utxo, datum]) =>
-          toHex(datum.iasset) === toHex(iasset) &&
-          match(datum.orderType)
-            .with(
-              { BuyIAssetOrder: P.select() },
-              (content) =>
-                isSameAssetClass(collateralAsset, content.collateralAsset) &&
-                rationalToFloat(content.maxPrice) >=
-                  rationalToFloat(iassetPrice),
-            )
-            // Only buy order types
-            .otherwise(() => false) &&
-          !isBuyOrderFullyRedeemed(utxo.assets, datum.orderType, iassetPrice),
-      ),
-    ),
-  );
-
-  // Sorted from highest to lowest by lovelaces to spend
-  let result: [UTxO, RobDatum][] = [];
-  let runningSum = 0n;
-
-  for (let i = 0; i < shuffled.length; i++) {
-    const element = shuffled[i];
-
-    const lovelacesToSpend = robCollateralAmtToSpend(
-      element[0].assets,
-      element[1].orderType,
-    );
-
-    const remainingToRedeem = targetCollateralToSpend - runningSum;
-    const remainingToPayout = iassetValueOfCollateral(
-      remainingToRedeem,
-      iassetPrice,
-    );
-
-    // When we can't add a new redemption because otherwise there would be no payout.
-    // Try to replace the smallest collected with a following larger one when available.
-    if (result.length > 0 && remainingToPayout <= 0n) {
-      const last = result[result.length - 1];
-
-      const lastSummary = robBuyOrderSummary(
-        last[0].assets,
-        last[1].orderType,
-        iassetPrice,
-      );
-
-      // Pop the smallest collected when the current is larger.
-      if (lastSummary.redeemableCollateral < lovelacesToSpend) {
-        result.pop()!;
-        runningSum -= lastSummary.redeemableCollateral;
-      } else {
-        continue;
-      }
-    }
-
-    result = insertSorted(
-      result,
-      element,
-      Ord.contramap<bigint, [UTxO, RobDatum]>(
-        ([utxo, dat]) => robCollateralAmtToSpend(utxo.assets, dat.orderType),
-        // From highest to lowest
-      )(Ord.reverse(BigIntOrd)),
-    );
-    runningSum += lovelacesToSpend;
-
-    // When more items than max allowed, pop the one with smallest value
-    if (result.length > maxLrpsInTx) {
-      const popped = result.pop()!;
-      runningSum -= robCollateralAmtToSpend(
-        popped[0].assets,
-        popped[1].orderType,
-      );
-    }
-
-    if (runningSum >= targetCollateralToSpend) {
-      return result;
-    }
-  }
-
-  const remainingToSpend = targetCollateralToSpend - runningSum;
-
-  if (
-    remainingToSpend > 0n &&
-    iassetValueOfCollateral(remainingToSpend, iassetPrice) > 0n
-  ) {
-    throw new Error("Couldn't achieve target lovelaces");
-  }
-
-  return result;
-}

package/src/contracts/rob/scripts.ts

@@ -1,35 +0,0 @@
-import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
-import { castRobParams, RobParams } from './types';
-import {
-  fromSystemParamsAssetLucid,
-  RobParamsSP,
-} from '../../types/system-params';
-import { _robValidator } from '../../validators/rob-validator';
-
-export const mkRobValidator = (params: RobParams): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_robValidator.cborHex, [castRobParams(params)]),
-  };
-};
-
-export const mkRobValidatorFromSP = (
-  params: RobParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_robValidator.cborHex, [
-      castRobParams({
-        versionRecordToken: fromSystemParamsAssetLucid(
-          params.versionRecordToken,
-        ),
-        iassetValHash: params.iassetValHash,
-        iassetAuthToken: fromSystemParamsAssetLucid(params.iassetAuthToken),
-        collateralAssetAuthToken: fromSystemParamsAssetLucid(
-          params.collateralAssetAuthToken,
-        ),
-        iassetPolicyId: params.iassetPolicyId.unCurrencySymbol,
-      }),
-    ]),
-  };
-};