@indigo-labs/indigo-sdk 0.2.42 → 0.3.0

package/src/contracts/rob/helpers.ts

@@ -0,0 +1,405 @@
+import {
+  addAssets,
+  Assets,
+  fromHex,
+  toHex,
+  TxBuilder,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import {
+  RobDatum,
+  parseRobDatumOrThrow,
+  serialiseRobDatum,
+  serialiseRobRedeemer,
+} from './types-new';
+import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
+import { zeroNegatives } from '../../utils/bigint-utils';
+import {
+  readonlyArray as RA,
+  array as A,
+  function as F,
+  option as O,
+} 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,
+  rationalDiv,
+  rationalFloor,
+  rationalFromInt,
+  rationalMul,
+} from '../../types/rational';
+
+export const MIN_ROB_COLLATERAL_AMT = 3_000_000n;
+
+export function robAmountToSpend(
+  utxo: UTxO,
+  datum: RobDatum,
+  sysParams: SystemParams,
+): bigint {
+  return match(datum.orderType)
+    .returnType<bigint>()
+    .with({ BuyIAssetOrder: P.select() }, (content) => {
+      if (isSameAssetClass(adaAssetClass, content.collateralAsset)) {
+        return zeroNegatives(
+          lovelacesAmt(utxo.assets) - MIN_ROB_COLLATERAL_AMT,
+        );
+      } else {
+        return assetClassValueOf(utxo.assets, content.collateralAsset);
+      }
+    })
+    .with({ SellIAssetOrder: P.any }, (_) => {
+      return assetClassValueOf(utxo.assets, {
+        currencySymbol: fromHex(
+          sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+        ),
+        tokenName: datum.iasset,
+      });
+    })
+    .exhaustive();
+}
+
+export function isFullyRedeemed(
+  utxo: UTxO,
+  datum: RobDatum,
+  sysParams: SystemParams,
+): boolean {
+  // TODO: or when the price doesn't allow single token redemption
+  return robAmountToSpend(utxo, datum, sysParams) === 0n;
+}
+
+// /**
+//  * Calculate the actually redeemable lovelaces taking into account:
+//  *  - LRP datum
+//  *  - UTXO's value
+//  *  - min redemption
+//  *
+//  * This helps to handle incorrectly initialised LRPs, too.
+//  */
+// export function lrpRedeemableLovelacesInclReimb(
+//   lrp: [UTxO, RobDatum],
+//   lrpParams: RobParamsSP,
+// ): bigint {
+//   const datum = lrp[1];
+//   const utxo = lrp[0];
+
+//   let res = 0n;
+//   // When incorrectly initialised
+//   if (datum.lovelacesToSpend > lovelacesAmt(utxo.assets)) {
+//     res = bigintMax(lovelacesAmt(utxo.assets) - MIN_ROB_COLLATERAL_AMT, 0n);
+//   } else {
+//     res = datum.lovelacesToSpend;
+//   }
+
+//   if (res < lrpParams.minRedemptionLovelacesAmt) {
+//     return 0n;
+//   }
+
+//   return res;
+// }
+
+/**
+ * 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: bigint | null,
+): TxBuilder {
+  return F.pipe(
+    redemptions,
+    A.reduceWithIndex<[UTxO, bigint], TxBuilder>(
+      tx,
+      (idx, acc, [robUtxo, spendAmt]) => {
+        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 = spendAmt;
+
+            const reimburstmentIAsset = calculateFeeFromRatio(
+              redemptionReimbursementRatio,
+              payoutIAssetAmt,
+            );
+
+            const collateralForRedemption = rationalFloor(
+              rationalMul(
+                rationalFromInt(payoutIAssetAmt - reimburstmentIAsset),
+                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 = spendAmt;
+
+            const reimbursementCollateral = calculateFeeFromRatio(
+              redemptionReimbursementRatio,
+              payoutCollateralAmt,
+            );
+
+            const redeemedIAssetAmt = rationalFloor(
+              rationalDiv(
+                rationalFromInt(payoutCollateralAmt - reimbursementCollateral),
+                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('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 != null
+                      ? { OracleRefInputIdx: oracleIdx }
+                      : 'OracleVoid',
+                },
+              }),
+          })
+          .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 ADA that can be redeemed (including reimbursement fee).
+//  * Taking into account ncorrectly initialised LRPs (without base collateral).
+//  */
+// export function calculateTotalAdaForRedemption(
+//   iasset: Uint8Array<ArrayBufferLike>,
+//   iassetPrice: OnChainDecimal,
+//   lrpParams: RobParamsSP,
+//   allLrps: [UTxO, RobDatum][],
+//   /**
+//    * How many LRPs can be redeemed in a single Tx.
+//    */
+//   maxLrpsInTx: number,
+// ): bigint {
+//   return F.pipe(
+//     allLrps,
+//     A.filterMap(([utxo, datum]) => {
+//       if (
+//         toHex(datum.iasset) !== toHex(iasset) ||
+//         datum.maxPrice.getOnChainInt < iassetPrice.getOnChainInt
+//       ) {
+//         return O.none;
+//       }
+
+//       const lovelacesToSpend = lrpRedeemableLovelacesInclReimb(
+//         [utxo, datum],
+//         lrpParams,
+//       );
+
+//       if (lovelacesToSpend === 0n) {
+//         return O.none;
+//       }
+
+//       // Subtract the reimbursement fee here on each iteration to simulate real redemptions.
+//       return O.some(lovelacesToSpend);
+//     }),
+//     // 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(maxLrpsInTx),
+//     sum,
+//   );
+// }
+
+// export function randomLrpsSubsetSatisfyingTargetLovelaces(
+//   iasset: Uint8Array<ArrayBufferLike>,
+//   // Including the reimbursement percentage
+//   targetLovelacesToSpend: bigint,
+//   iassetPrice: OnChainDecimal,
+//   allLrps: [UTxO, RobDatum][],
+//   lrpParams: RobParamsSP,
+//   /**
+//    * How many LRPs can be redeemed in a single Tx.
+//    */
+//   maxLrpsInTx: number,
+//   randomiseFn: (arr: [UTxO, RobDatum][]) => [UTxO, RobDatum][] = shuffle,
+// ): [UTxO, RobDatum][] {
+//   if (targetLovelacesToSpend < lrpParams.minRedemptionLovelacesAmt) {
+//     throw new Error("Can't redeem less than the minimum.");
+//   }
+
+//   const shuffled = randomiseFn(
+//     F.pipe(
+//       allLrps,
+//       A.filter(
+//         ([_, datum]) =>
+//           toHex(datum.iasset) === toHex(iasset) &&
+//           datum.maxPrice.getOnChainInt >= iassetPrice.getOnChainInt,
+//       ),
+//     ),
+//   );
+
+//   // 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 = lrpRedeemableLovelacesInclReimb(
+//       element,
+//       lrpParams,
+//     );
+
+//     // Do not add LRPs with smaller lovelacesToSpend than the minRedemption
+//     // to the random subset.
+//     if (lovelacesToSpend < lrpParams.minRedemptionLovelacesAmt) {
+//       continue;
+//     }
+
+//     // When we can't add a new redemption because otherwise the min redemption
+//     // wouldn't be satisfied.
+//     // Try to replace the smallest collected with a following larger one when available.
+//     if (
+//       result.length > 0 &&
+//       targetLovelacesToSpend - runningSum < lrpParams.minRedemptionLovelacesAmt
+//     ) {
+//       const last = result[result.length - 1];
+
+//       // Pop the smallest collected when the current is larger.
+//       if (lrpRedeemableLovelacesInclReimb(last, lrpParams) < lovelacesToSpend) {
+//         const popped = result.pop()!;
+//         runningSum -= lrpRedeemableLovelacesInclReimb(popped, lrpParams);
+//       } else {
+//         continue;
+//       }
+//     }
+
+//     result = insertSorted(
+//       result,
+//       element,
+//       Ord.contramap<bigint, [UTxO, RobDatum]>(
+//         ([_, dat]) => dat.lovelacesToSpend,
+//         // 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 -= lrpRedeemableLovelacesInclReimb(popped, lrpParams);
+//     }
+
+//     if (runningSum >= targetLovelacesToSpend) {
+//       return result;
+//     }
+//   }
+
+//   if (
+//     targetLovelacesToSpend - runningSum >=
+//     lrpParams.minRedemptionLovelacesAmt
+//   ) {
+//     throw new Error("Couldn't achieve target lovelaces");
+//   }
+
+//   return result;
+// }

package/src/contracts/rob/scripts.ts

@@ -0,0 +1,35 @@
+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,
+      }),
+    ]),
+  };
+};